dsipts 1.1.5__py3-none-any.whl

dsipts/models/xlstm/xLSTM.py

@@ -0,0 +1,255 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+
+class mLSTM(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers, dropout=0.0):
+        super(mLSTM, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.dropout = dropout
+
+        self.lstms = nn.ModuleList([nn.LSTMCell(input_size, hidden_size) for _ in range(num_layers)])
+        self.dropout_layers = nn.ModuleList([nn.Dropout(dropout) for _ in range(num_layers - 1)])
+
+        self.W_q = nn.Linear(input_size, hidden_size)
+        self.W_k = nn.Linear(input_size, hidden_size)
+        self.W_v = nn.Linear(input_size, hidden_size)
+
+        self.exp_input_gates = nn.ModuleList([nn.Linear(input_size, hidden_size) for _ in range(num_layers)])
+        self.exp_forget_gates = nn.ModuleList([nn.Linear(input_size, hidden_size) for _ in range(num_layers)])
+        self.output_gates = nn.ModuleList([nn.Linear(hidden_size, hidden_size) for _ in range(num_layers)])
+        
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        for lstm in self.lstms:
+            nn.init.xavier_uniform_(lstm.weight_ih)
+            nn.init.xavier_uniform_(lstm.weight_hh)
+            nn.init.zeros_(lstm.bias_ih) 
+            nn.init.zeros_(lstm.bias_hh)
+        
+        nn.init.xavier_uniform_(self.W_q.weight)
+        nn.init.xavier_uniform_(self.W_k.weight)
+        nn.init.xavier_uniform_(self.W_v.weight)
+        nn.init.zeros_(self.W_q.bias)
+        nn.init.zeros_(self.W_k.bias) 
+        nn.init.zeros_(self.W_v.bias)
+        
+        for gate in self.exp_input_gates + self.exp_forget_gates + self.output_gates:
+            nn.init.xavier_uniform_(gate.weight)
+            nn.init.zeros_(gate.bias)
+
+    def forward(self, input_seq, hidden_state=None):
+        batch_size = input_seq.size(0)
+        seq_length = input_seq.size(1)
+
+        if hidden_state is None:
+            hidden_state = self.init_hidden(batch_size)
+
+        output_seq = []
+        for t in range(seq_length):
+            x = input_seq[:, t, :]
+            queries = self.W_q(x)
+            keys = self.W_k(x)
+            values = self.W_v(x)
+
+            new_hidden_state = []
+            for i, (lstm, dropout, i_gate, f_gate, o_gate) in enumerate(zip(self.lstms, self.dropout_layers, self.exp_input_gates, self.exp_forget_gates, self.output_gates)):
+                if hidden_state[i][0] is None:
+                    h, C = lstm(x)
+                else:
+                    h, C = hidden_state[i]
+                
+                ii = torch.exp(i_gate(x))
+                f = torch.exp(f_gate(x))
+
+                C_t = f * C + ii * torch.matmul(values.unsqueeze(2), keys.unsqueeze(1)).squeeze(1)
+                attn_output = torch.matmul(queries, C_t).squeeze(2)
+                
+                o = torch.sigmoid(o_gate(h))
+                h = o * attn_output
+                new_hidden_state.append((h, C_t))
+                
+                if i < self.num_layers - 1:
+                    x = dropout(h)
+                else:
+                    x = h
+            hidden_state = new_hidden_state
+            output_seq.append(x)
+
+        output_seq = torch.stack(output_seq, dim=1)
+        return output_seq, hidden_state
+
+    def init_hidden(self, batch_size):
+        hidden_state = []
+        for lstm in self.lstms:
+            h = torch.zeros(batch_size, self.hidden_size, device=lstm.weight_ih.device)
+            C = torch.zeros(batch_size, self.hidden_size, self.hidden_size, device=lstm.weight_ih.device)
+            hidden_state.append((h, C))
+        return hidden_state
+class sLSTM(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers, dropout=0.0):
+        super(sLSTM, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.dropout = dropout
+
+        self.lstms = nn.ModuleList([nn.LSTMCell(input_size if i == 0 else hidden_size, hidden_size) for i in range(num_layers)])
+        self.dropout_layers = nn.ModuleList([nn.Dropout(dropout) for _ in range(num_layers - 1)])
+
+        self.exp_forget_gates = nn.ModuleList([nn.Linear(hidden_size, hidden_size) for _ in range(num_layers)])
+        self.exp_input_gates = nn.ModuleList([nn.Linear(hidden_size, hidden_size) for _ in range(num_layers)])
+        
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        for lstm in self.lstms:
+            nn.init.xavier_uniform_(lstm.weight_ih)
+            nn.init.xavier_uniform_(lstm.weight_hh)
+            nn.init.zeros_(lstm.bias_ih)
+            nn.init.zeros_(lstm.bias_hh)
+        
+        for gate in self.exp_forget_gates + self.exp_input_gates:
+            nn.init.xavier_uniform_(gate.weight)
+            nn.init.zeros_(gate.bias)
+
+    def forward(self, input_seq, hidden_state=None):
+        batch_size = input_seq.size(0)
+        seq_length = input_seq.size(1)
+
+        if hidden_state is None:
+            hidden_state = self.init_hidden(batch_size)
+
+        output_seq = []
+        for t in range(seq_length):
+            x = input_seq[:, t, :]
+            new_hidden_state = []
+            for i, (lstm, dropout, f_gate, i_gate) in enumerate(zip(self.lstms, self.dropout_layers, self.exp_forget_gates, self.exp_input_gates)):
+                if hidden_state[i][0] is None:
+                    h, c = lstm(x)
+                else:
+                    h, c = lstm(x, (hidden_state[i][0], hidden_state[i][1]))
+
+                f = torch.exp(f_gate(h))
+                ii = torch.exp(i_gate(h))
+                c = f * c + ii * lstm.weight_hh.new_zeros(batch_size, self.hidden_size)
+                new_hidden_state.append((h, c))
+
+                if i < self.num_layers - 1:
+                    x = dropout(h)
+                else:
+                    x = h
+            hidden_state = new_hidden_state
+            output_seq.append(x)
+
+        output_seq = torch.stack(output_seq, dim=1)
+        return output_seq, hidden_state
+
+    def init_hidden(self, batch_size):
+        hidden_state = []
+        for lstm in self.lstms:
+            h = torch.zeros(batch_size, self.hidden_size, device=lstm.weight_ih.device)
+            c = torch.zeros(batch_size, self.hidden_size, device=lstm.weight_ih.device)
+            hidden_state.append((h, c))
+        return hidden_state
+
+class xLSTMBlock(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers, dropout=0.0, bidirectional=False, lstm_type="slstm"):
+        super(xLSTMBlock, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.dropout = dropout
+        self.bidirectional = bidirectional
+        self.lstm_type = lstm_type
+
+        if lstm_type == "slstm":
+            self.lstm = sLSTM(input_size, hidden_size, num_layers, dropout)
+        elif lstm_type == "mlstm":
+            self.lstm = mLSTM(input_size, hidden_size, num_layers, dropout)
+        else:
+            raise ValueError(f"Invalid LSTM type: {lstm_type}")
+
+        self.norm = nn.LayerNorm(input_size)
+        self.activation = nn.GELU()
+        self.dropout_layer = nn.Dropout(dropout)
+
+        if bidirectional:
+            self.proj = nn.Linear(2 * hidden_size, input_size)
+        else:
+            if lstm_type == "mlstm":
+                self.up_proj = nn.Sequential(
+                    nn.Linear(input_size, 4 * input_size), 
+                    nn.GELU(),
+                    nn.Linear(4 * input_size, input_size)
+                )
+            self.proj = nn.Linear(hidden_size, input_size)
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        if hasattr(self, "up_proj"):
+            nn.init.xavier_uniform_(self.up_proj[0].weight)
+            nn.init.zeros_(self.up_proj[0].bias)
+            nn.init.xavier_uniform_(self.up_proj[2].weight)
+            nn.init.zeros_(self.up_proj[2].bias)
+
+        nn.init.xavier_uniform_(self.proj.weight)
+        nn.init.zeros_(self.proj.bias)
+
+    def forward(self, input_seq, hidden_state=None):
+        if hasattr(self, "up_proj"):
+            input_seq = self.up_proj(input_seq)
+
+        lstm_output, hidden_state = self.lstm(input_seq, hidden_state)
+        if self.lstm_type == "slstm":
+            hidden_state = [[hidden_state[i][0], hidden_state[i][1]] for i in range(len(hidden_state))]
+
+        if self.bidirectional:
+            lstm_output = torch.cat((lstm_output[:, :, :self.hidden_size], lstm_output[:, :, -self.hidden_size:]), dim=-1)
+
+        output = self.activation(self.proj(lstm_output))
+        output = self.norm(output + input_seq)
+        output = self.dropout_layer(output)
+
+        return output, hidden_state
+
+
+
+class xLSTM(nn.Module):
+    def __init__(self, input_size, hidden_size, num_layers, num_blocks,
+                 dropout=0.0, bidirectional=False, lstm_type="slstm"):
+        super(xLSTM, self).__init__()
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.num_layers = num_layers
+        self.num_blocks = num_blocks
+        self.dropout = dropout
+        self.bidirectional = bidirectional
+        self.lstm_type = lstm_type
+
+        self.blocks = nn.ModuleList([xLSTMBlock(hidden_size,
+                                                hidden_size, num_layers, dropout, bidirectional, lstm_type)
+                                     for i in range(num_blocks)])
+
+        self.initial = nn.Linear(self.input_size,self.hidden_size)
+
+    def forward(self, input_seq, hidden_states=None):
+
+        if hidden_states is None:
+            hidden_states = [None] * self.num_blocks
+        output_seq = self.initial(input_seq)
+        for i, block in enumerate(self.blocks):
+
+            output_seq, hidden_state = block(output_seq, hidden_states[i])
+            if self.lstm_type == "slstm":
+                hidden_states[i] = [[hidden_state[j][0], hidden_state[j][1]] for j in range(len(hidden_state))]
+            else:
+                hidden_states[i] = hidden_state
+
+        return output_seq, hidden_states

dsipts-1.1.5.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: dsipts
+Version: 1.1.5
+Summary: Unified library for timeseries modelling
+Author-email: Andrea Gobbi <agobbi@fbk.eu>
+Project-URL: Homepage, https://github.com/DSIP-FBK/DSIPTS
+Project-URL: Docs, https://dsip-fbk.github.io/DSIPTS/
+Requires-Python: ==3.11.13
+Description-Content-Type: text/markdown
+Requires-Dist: aim==3.20.1
+Requires-Dist: beautifulsoup4==4.12.0
+Requires-Dist: einops>=0.8.1
+Requires-Dist: html-table-parser-python3==0.3.1
+Requires-Dist: html5lib>=1.1
+Requires-Dist: hydra-core>=1.3.2
+Requires-Dist: hydra-joblib-launcher>=1.2.0
+Requires-Dist: hydra-optuna-sweeper>=1.2.0
+Requires-Dist: hydra-submitit-launcher>=1.2.0
+Requires-Dist: ipykernel>=6.30.1
+Requires-Dist: lightning>=2.5.4
+Requires-Dist: matplotlib>=3.10.6
+Requires-Dist: nbformat>=5.10.4
+Requires-Dist: numba>=0.61.2
+Requires-Dist: numpy<2.0.0
+Requires-Dist: pandas>=2.3.2
+Requires-Dist: plotly>=6.3.0
+Requires-Dist: scikit-learn>=1.7.1
+Requires-Dist: sphinx>=8.2.3
+Requires-Dist: sphinx-mdinclude>=0.6.2
+Requires-Dist: sphinx-pdj-theme>=0.7.3
+Requires-Dist: transformers>=4.56.0

dsipts-1.1.5.dist-info/RECORD

@@ -0,0 +1,81 @@
+dsipts/__init__.py,sha256=k3fLLS66oWHI_TOLccv-foIlNZNO_NMTABw14OntaAc,1651
+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/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/DilatedConvED.py,sha256=fXk1-EWiRC5J_VIepTjYKya_D02SlEAkyiJcCjhW_XU,14004
+dsipts/models/Duet.py,sha256=EharWHT_r7tEYIk7BkozVLPZ0xptE5mmQmeFGm3uBsA,7628
+dsipts/models/ITransformer.py,sha256=jO8wxLaC06Wgu4GncrFFTISv3pVyfFLLhQvbEOYsz6Y,7368
+dsipts/models/Informer.py,sha256=ByJ00qGk12ONFF7NZWAACzxxRb5UXcu5wpkGMYX9Cq4,6920
+dsipts/models/LinearTS.py,sha256=B0-Sz4POwUyl-PN2ssSx8L-ZHgwrQQPcMmreyvSS47U,9104
+dsipts/models/PatchTST.py,sha256=Z7DM1Kw5Ym8Hh9ywj0j9RuFtKaz_yVZmKFIYafjceM8,9061
+dsipts/models/Persistent.py,sha256=URwyaBb0M7zbPXSGMImtHlwC9XCy-OquFCwfWvn3P70,1249
+dsipts/models/RNN.py,sha256=W6-3ZPD6vkcNoxV9liqcm_8RD8qfF1JY-J7M1ngk6LA,9594
+dsipts/models/Samformer.py,sha256=s61Hi1o9iuw-KgSBPfiE80oJcK1j2fUA6N9f5BJgKJc,5551
+dsipts/models/TFT.py,sha256=JO2-AKIUag7bfm9Oeo4KmGfdYZJbzQBHPDqGVg0WUZI,13830
+dsipts/models/TIDE.py,sha256=i8qXac2gImEVgE2X6cNxqW5kuQP3rzWMlQNdgJbNmKM,13033
+dsipts/models/TTM.py,sha256=WpCiTN0qX3JFO6xgPLedoqMKXUC2pQpNAe9ee-Rw89Q,10602
+dsipts/models/TimeXER.py,sha256=aCg0003LxYZzqZWyWugpbW_iOybcdHN4OH6_v77qp4o,7056
+dsipts/models/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/utils.py,sha256=H1lr1lukDk7FNyXXTJh217tyTBsBW8hVDQ6jL9oev7I,21765
+dsipts/models/autoformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsipts/models/autoformer/layers.py,sha256=xHt8V1lKdD1cIvgxXdDbI_EqOz4zgOQ6LP8l7M1pAxM,13276
+dsipts/models/crossformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsipts/models/crossformer/attn.py,sha256=nUPdhU0wul222We8lvtr7SGeMy2VA_86vaMhnzH1t9g,4580
+dsipts/models/crossformer/cross_decoder.py,sha256=mTo7urCnXrEgynYgyQSjRdE1T8s5fSE1daUaFyATeHU,3032
+dsipts/models/crossformer/cross_embed.py,sha256=SkOHN5KwRObNYzu858Q40EMSgqCkBzNq2SYwoJ0SdcQ,609
+dsipts/models/crossformer/cross_encoder.py,sha256=_ivTGddvvN82Q1E_TRPnLDwC2_s3xOIQXfUQ5lVbOZU,3238
+dsipts/models/d3vae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsipts/models/d3vae/diffusion_process.py,sha256=qbe-8da4TnPb-152W6JVyUKqllVgfOda43Yr_e3XebE,6050
+dsipts/models/d3vae/embedding.py,sha256=3S6QnOtjcJJYIFm0UcNhO12HSj6MisCTYm3ky3zuhmQ,3797
+dsipts/models/d3vae/encoder.py,sha256=c6cq9xKzT_xGcCf6hZy1UE2mxCPtuKwUsQXr1JJKfnE,13114
+dsipts/models/d3vae/model.py,sha256=s6tqGdZ9dQdPXRLsNxHIbPpSs07t-tJttjTHCeibL48,9238
+dsipts/models/d3vae/neural_operations.py,sha256=C70kUtQ0ox9MeXBdu4rPDqt022_hVtcN_MNOD8y1cqI,10594
+dsipts/models/d3vae/resnet.py,sha256=3bnlrEBM2DGiAJV8TeSv2tm27Gm-_P6hee41t8QQFL8,5520
+dsipts/models/d3vae/utils.py,sha256=fmUsE_67uwizjeR1_pDdsndyQddbqt27Lv31XBEn-gw,23798
+dsipts/models/duet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsipts/models/duet/layers.py,sha256=ikMAKr4DzhGt9J1KuBBQzVYXMHZUZVsV29P6TVJCa_Y,18141
+dsipts/models/duet/masked.py,sha256=lkdAB5kwAgV7QfBSVP_QeDr_mB09Rz4302p-KwZpUV4,7111
+dsipts/models/informer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsipts/models/informer/attn.py,sha256=ghrQGfAqt-Z_7qU5D_aixobmwk6pBKMLAdaNfg-QZbo,6839
+dsipts/models/informer/decoder.py,sha256=gvMfwI6Lyi0JIZlXqx6TVDYEUwRHFDYekzfbEb0A2ck,1759
+dsipts/models/informer/embed.py,sha256=hYBIhZvaF9RUuMxF8_-ybpnOvQ2mgqzn3zPFv8Okx6k,4449
+dsipts/models/informer/encoder.py,sha256=H9O_2hOJDcISj_CFbFcZR-tU3n-NtQFnlpNy3G5p8tY,3573
+dsipts/models/itransformer/Embed.py,sha256=BM6v2BsRuLNGPEN4L2HSyC1VHXjWTx63L0WH8_FJpsA,5122
+dsipts/models/itransformer/SelfAttention_Family.py,sha256=739Jvoo1vJ6TR53zG6msc71DdkC0dUgVZ0ZdP58Dd_s,13674
+dsipts/models/itransformer/Transformer_EncDec.py,sha256=kkHdKKJ48gFaaW2MHy0YFd5xvaM3YoN9Jk4wsKO8RP4,4898
+dsipts/models/itransformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsipts/models/patchtst/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsipts/models/patchtst/layers.py,sha256=o8s--1NQcE9ItlkHse_NUxix0xfxJ9yNSmy98PMVvyc,24177
+dsipts/models/samformer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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/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
+dsipts/models/ttm/configuration_tinytimemixer.py,sha256=b_cvewRZQuPSuJx0GEDFIY85hThf7612ynukDciYlZE,16414
+dsipts/models/ttm/consts.py,sha256=tPL5yxHR9fQaSMaOREcj-7ML8lZ_FX5ZPiLwkBo2814,340
+dsipts/models/ttm/modeling_tinytimemixer.py,sha256=55G12e_Vei2aK9g-C5PDwwri-ujXbkQ5cpH4nUkbiiU,87006
+dsipts/models/ttm/utils.py,sha256=dpBUg1Nci_9-MBnWMHiZUW7WWAQ4oRn_it3X5FdCOhE,26379
+dsipts/models/vva/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsipts/models/vva/minigpt.py,sha256=bg0JddqSD322uxSGexen3nPXL_hGTsk3vNLR62d7-w8,3551
+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.5.dist-info/METADATA,sha256=qR-kBKMsp_LN4nGOzRE6piEsaiDaD5WUB8-ASMRWbAQ,1082
+dsipts-1.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dsipts-1.1.5.dist-info/top_level.txt,sha256=i6o0rf5ScFwZK21E89dSKjVNjUBkrEQpn0-Vij43748,7
+dsipts-1.1.5.dist-info/RECORD,,

dsipts-1.1.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dsipts-1.1.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+dsipts