dsipts 1.1.6__py3-none-any.whl → 1.1.8__py3-none-any.whl

dsipts/__init__.py

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

dsipts/data_structure/data_structure.py

@@ -800,6 +800,7 @@ class TimeSeries():
                                 callbacks=[checkpoint_callback,mc],
                                 auto_lr_find=auto_lr_find, 
                                 accelerator=accelerator,
+                                log_every_n_steps=1,
                                 devices=devices,
                                 strategy=strategy,
                                 enable_progress_bar=False,
@@ -813,6 +814,7 @@ class TimeSeries():
                                 callbacks=[checkpoint_callback,mc],
                                 strategy='auto',
                                 devices=devices,
+                                log_every_n_steps=5,
                                 enable_progress_bar=False,
                                 precision=precision,
                                 gradient_clip_val=gradient_clip_val,

dsipts/models/DilatedConv.py

@@ -231,28 +231,11 @@ class DilatedConv(Base):
                                             activation(),
                                             nn.Linear(hidden_RNN//4,1)))
         
+        self.return_additional_loss = True
         
 
         
 
-    def training_step(self, batch, batch_idx):
-        """
-        pythotrch lightening stuff
-        
-        :meta private:
-        """
-        y_hat,score = self(batch)
-        return self.compute_loss(batch,y_hat)#+torch.abs(score-self.glu_percentage)*loss/5.0 ##TODO investigating
-    
-    def validation_step(self, batch, batch_idx):
-        """
-        pythotrch lightening stuff
-        
-        :meta private:
-        """
-        y_hat,score = self(batch)
-        return self.compute_loss(batch,y_hat)#+torch.abs(score-self.glu_percentage)*loss/5.0 ##TODO investigating
-
     def forward(self, batch):
         """It is mandatory to implement this method
 
@@ -332,11 +315,11 @@ class DilatedConv(Base):
         res = res.reshape(B,self.future_steps,-1,self.mul)
         if self.remove_last:
             res+=x_start.unsqueeze(1)
-        
+
       
         return res, score
 
     def inference(self, batch:dict)->torch.tensor:
-        
+
         res, score = self(batch)
         return res

dsipts/models/RNN.py

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

dsipts/models/Simple.py

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

dsipts/models/base.py

@@ -154,7 +154,7 @@ class Base(pl.LightningModule):
             assert self.out_channels==1, "Classification require only one channel"
 
         self.future_steps = future_steps
-        
+        self.return_additional_loss = False
         beauty_string(self.description,'info',True)
     @abstractmethod
     def forward(self, batch:dict)-> torch.tensor:
@@ -247,14 +247,22 @@ class Base(pl.LightningModule):
             opt = self.optimizers()
             def closure():
                 opt.zero_grad()
-                y_hat = self(batch)
-                loss = self.compute_loss(batch,y_hat)
+                if self.return_additional_loss:
+                    y_hat,score = self(batch)
+                    loss = self.compute_loss(batch,y_hat) + score
+                else:
+                    y_hat = self(batch)
+                    loss = self.compute_loss(batch,y_hat)
                 self.manual_backward(loss)
                 return loss
 
             opt.step(closure)
-            y_hat = self(batch)
-            loss = self.compute_loss(batch,y_hat)
+            if self.return_additional_loss:
+                y_hat,score = self(batch)
+                loss = self.compute_loss(batch,y_hat)+score
+            else:
+                y_hat = self(batch)
+                loss = self.compute_loss(batch,y_hat)
             
             #opt.first_step(zero_grad=True)
 
@@ -269,8 +277,14 @@ class Base(pl.LightningModule):
    
             #self.trainer.fit_loop.epoch_loop.manual_optimization.optim_step_progress.increment("optimizer")
         else:
-            y_hat = self(batch)
-            loss = self.compute_loss(batch,y_hat)
+            if self.return_additional_loss:
+                y_hat,score = self(batch)
+                loss = self.compute_loss(batch,y_hat)+score
+            else:
+                y_hat = self(batch)
+                loss = self.compute_loss(batch,y_hat)
+            
+        self.train_epoch_metrics.append(loss.item())
         return loss
 
     
@@ -280,7 +294,11 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
-        y_hat = self(batch)
+        if self.return_additional_loss:
+            y_hat,score = self(batch)
+        else:
+            y_hat = self(batch)
+            score = 0
         if batch_idx==0:
             if self.use_quantiles:
                 idx = 1
@@ -301,7 +319,7 @@ class Base(pl.LightningModule):
                     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)
+        return self.compute_loss(batch,y_hat)+score
 
 
     def validation_epoch_end(self, outs):
@@ -310,8 +328,12 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
-    
-        loss = torch.stack(outs).mean()
+        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)
 
@@ -406,12 +428,7 @@ class Base(pl.LightningModule):
             
         elif self.loss_type=='dilated':
             #BxLxCxMUL
-            if self.persistence_weight==0.1:
-                alpha = 0.25
-            if self.persistence_weight==1:
-                alpha = 0.5
-            else:
-                alpha  =0.75
+ 
             alpha = self.persistence_weight 
             gamma = 0.01
             loss = 0
@@ -422,8 +439,8 @@ class Base(pl.LightningModule):
                 loss+= dilate_loss( batch['y'][:,:,i:i+1],x[:,:,i:i+1], alpha, gamma, y_hat.device)
             
         elif self.loss_type=='huber':
-            loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight/10)   
-            #loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight)   
+            loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight)   
+
             if self.use_quantiles is False:
                 x = y_hat[:,:,:,0]
             else:

dsipts/models/base_v2.py

@@ -157,7 +157,7 @@ class Base(pl.LightningModule):
 
 
         self.future_steps = future_steps
-        
+        self.return_additional_loss = False
         beauty_string(self.description,'info',True)
     @abstractmethod
     def forward(self, batch:dict)-> torch.tensor:
@@ -250,14 +250,22 @@ class Base(pl.LightningModule):
             opt = self.optimizers()
             def closure():
                 opt.zero_grad()
-                y_hat = self(batch)
-                loss = self.compute_loss(batch,y_hat)
+                if self.return_additional_loss:
+                    y_hat,score = self(batch)
+                    loss = self.compute_loss(batch,y_hat) + score
+                else:
+                    y_hat = self(batch)
+                    loss = self.compute_loss(batch,y_hat)
                 self.manual_backward(loss)
                 return loss
 
             opt.step(closure)
-            y_hat = self(batch)
-            loss = self.compute_loss(batch,y_hat)
+            if self.return_additional_loss:
+                y_hat,score = self(batch)
+                loss = self.compute_loss(batch,y_hat)+score
+            else:
+                y_hat = self(batch)
+                loss = self.compute_loss(batch,y_hat)
             
             #opt.first_step(zero_grad=True)
 
@@ -272,8 +280,12 @@ class Base(pl.LightningModule):
    
             #self.trainer.fit_loop.epoch_loop.manual_optimization.optim_step_progress.increment("optimizer")
         else:
-            y_hat = self(batch)
-            loss = self.compute_loss(batch,y_hat)
+            if self.return_additional_loss:
+                y_hat,score = self(batch)
+                loss = self.compute_loss(batch,y_hat)+score
+            else:
+                y_hat = self(batch)
+                loss = self.compute_loss(batch,y_hat)
             
         self.train_epoch_metrics.append(loss.item())
         return loss
@@ -285,7 +297,12 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
-        y_hat = self(batch)
+
+        if self.return_additional_loss:
+            y_hat,score = self(batch)
+        else:
+            y_hat = self(batch)
+            score = 0
         if batch_idx==0:
             if self.use_quantiles:
                 idx = 1
@@ -305,7 +322,7 @@ class Base(pl.LightningModule):
                     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))
+        self.validation_epoch_metrics.append(self.compute_loss(batch,y_hat)+score)
         return 
 
 
@@ -315,7 +332,12 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
-        avg = torch.stack(self.validation_epoch_metrics).mean()
+
+        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 = []
         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)
@@ -327,7 +349,11 @@ class Base(pl.LightningModule):
         
         :meta private:
         """
-        avg = np.stack(self.train_epoch_metrics).mean()
+        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()
         self.log("train_loss", avg,sync_dist=True)
         self.count_epoch+=1    
         self.train_epoch_metrics = []
@@ -411,24 +437,16 @@ class Base(pl.LightningModule):
             
         elif self.loss_type=='dilated':
             #BxLxCxMUL
-            if self.persistence_weight==0.1:
-                alpha = 0.25
-            if self.persistence_weight==1:
-                alpha = 0.5
-            else:
-                alpha  =0.75
+
             alpha = self.persistence_weight 
             gamma = 0.01
             loss = 0
             ##no multichannel here
-            for i in range(y_hat.shape[2]):
-                ##error here
-                
+            for i in range(y_hat.shape[2]):                
                 loss+= dilate_loss( batch['y'][:,:,i:i+1],x[:,:,i:i+1], alpha, gamma, y_hat.device)
             
         elif self.loss_type=='huber':
-            loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight/10)   
-            #loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight)   
+            loss = torch.nn.HuberLoss(reduction='mean', delta=self.persistence_weight)   
             if self.use_quantiles is False:
                 x = y_hat[:,:,:,0]
             else:

{dsipts-1.1.6.dist-info → dsipts-1.1.8.dist-info}/METADATA

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

{dsipts-1.1.6.dist-info → dsipts-1.1.8.dist-info}/RECORD

@@ -1,16 +1,16 @@
-dsipts/__init__.py,sha256=k3fLLS66oWHI_TOLccv-foIlNZNO_NMTABw14OntaAc,1651
+dsipts/__init__.py,sha256=UWmrBJ2LLoRCKLOyTBSJAw9n31o8ZwNjLoRAax5Wll8,1694
 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=5yHi6N0zXYzzKooy-91-5C1PEdNuU6ZWD-mApJvDOe8,58888
+dsipts/data_structure/data_structure.py,sha256=87VtKelx2EPoddrVYcja9dO5rQqaS83vZlQB_NY54PI,58994
 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=2gK69p4Jn9nEI2T2PebNOr70wpyR2QWxzmNQIXRAmJE,14845
+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
@@ -18,8 +18,9 @@ dsipts/models/Informer.py,sha256=ByJ00qGk12ONFF7NZWAACzxxRb5UXcu5wpkGMYX9Cq4,692
 dsipts/models/LinearTS.py,sha256=B0-Sz4POwUyl-PN2ssSx8L-ZHgwrQQPcMmreyvSS47U,9104
 dsipts/models/PatchTST.py,sha256=Z7DM1Kw5Ym8Hh9ywj0j9RuFtKaz_yVZmKFIYafjceM8,9061
 dsipts/models/Persistent.py,sha256=URwyaBb0M7zbPXSGMImtHlwC9XCy-OquFCwfWvn3P70,1249
-dsipts/models/RNN.py,sha256=W6-3ZPD6vkcNoxV9liqcm_8RD8qfF1JY-J7M1ngk6LA,9594
+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
@@ -27,8 +28,8 @@ dsipts/models/TimeXER.py,sha256=aCg0003LxYZzqZWyWugpbW_iOybcdHN4OH6_v77qp4o,7056
 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=uqAjDdAjpnDWBlEeGuy-SZir0K8GjsoyMgxwlT1DQYg,17523
-dsipts/models/base_v2.py,sha256=YHrejmxTmICXvLaXiual8j4dztSnWoQevIZWwy9zmfQ,17695
+dsipts/models/base.py,sha256=mIsEUkuyj_2MlYEvH97PPD790DrS0PQw4UCiWN8uqKI,18159
+dsipts/models/base_v2.py,sha256=jjlX5fIw2stCx5J3i3xFTgzYmCX-n8Lf4-4cLoq-diQ,18426
 dsipts/models/utils.py,sha256=H1lr1lukDk7FNyXXTJh217tyTBsBW8hVDQ6jL9oev7I,21765
 dsipts/models/autoformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsipts/models/autoformer/layers.py,sha256=xHt8V1lKdD1cIvgxXdDbI_EqOz4zgOQ6LP8l7M1pAxM,13276
@@ -75,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.6.dist-info/METADATA,sha256=MP2B3Mw4MQZ7toYvusCCpPDjel2e48dHzXxloanaz4w,24838
-dsipts-1.1.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dsipts-1.1.6.dist-info/top_level.txt,sha256=i6o0rf5ScFwZK21E89dSKjVNjUBkrEQpn0-Vij43748,7
-dsipts-1.1.6.dist-info/RECORD,,
+dsipts-1.1.8.dist-info/METADATA,sha256=fObwUSnqEBaCA_sDxvmOnfKsmb-Mu9gOrITzl3Tp4qQ,24794
+dsipts-1.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dsipts-1.1.8.dist-info/top_level.txt,sha256=i6o0rf5ScFwZK21E89dSKjVNjUBkrEQpn0-Vij43748,7
+dsipts-1.1.8.dist-info/RECORD,,