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

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"