updated models for L=512

README.md

@@ -1,20 +1,19 @@
 ---
 license: cc
 ---
-
 ## About
 
 This repository provides model weights to run load forecasting models trained on ComStock datasets. The companion dataset repository is [this](https://huggingface.co/datasets/APPFL/Illinois_load_datasets). The model definitions are present in the `models` directory. The corresponding trained model weights are present in the `weights` directory. The corresponding model keyword arguments (as a function of a provided `lookback` and `lookahead`) can be imported from the file `model_kwargs.py`.
 
-Note that `lookback` is denoted by `L` and `lookahead` by `T` in the weights directory. We provide weights for the following `(L,T)` pairs: `(96,4)`, `(96,48)`, and `(96,96)`.
+Note that `lookback` is denoted by `L` and `lookahead` by `T` in the weights directory. We provide weights for the following `(L,T)` pairs: `(512,4)`, `(512,48)`, and `(512,96)`, and for `HOM`ogenous and `HET`erogenous datasets.
 
 ## Data
 
-When using the companion [dataset](https://huggingface.co/datasets/APPFL/Illinois_load_datasets), the following points must be noted (see the dataset for more information on configuring the data loaders):
+When using the companion [dataset](https://huggingface.co/datasets/APPFL/Illinois_load_datasets), the following points must be noted (see the page for more information on configuring the data loaders):
 
 - All models accept normalized inputs and produce normalized outputs, i.e. set `normalize = True` when generating the datasets.
-- For Transformer, Autoformer, Informer, and TimesNet set `transformer = True`, while for LSTM and LSTNet, set `transformer = False`.
+- For Transformer, Autoformer, Informer, and TimesNet set `transformer = True`, while for LSTM, LSTNet, and PatchTST set `transformer = False`.
 
 ## Credits
 
-Some model definitions have been adapted from the code provided in the [TSLib Library](https://github.com/thuml/Time-Series-Library).
+Some model definitions have been adapted from the code provided in the [TSLib Library](https://github.com/thuml/Time-Series-Library).

model_kwargs.py

@@ -52,4 +52,15 @@ lstnet_kwargs = lambda lookback,lookahead:{
     'conv1_out_channels':8*4,
     'conv1_kernel_height':3*4,
     'recc1_out_channels':32*4
+}
+
+patchtst_kwargs = lambda lookback,lookahead:{
+    'enc_in': 6,
+    'dec_in': 2,
+    'c_out': 1,
+    'pred_len': lookahead,
+    'seq_len': lookback,
+    'd_model': 32*4,
+    'data_idx': [0,3,4,5,6,7],
+    'time_idx': [1,2]
 }

models/Autoformer.py

@@ -4,6 +4,9 @@ import torch.nn.functional as F
 import math
 import numpy as np
 
+# Modified from: https://github.com/thuml/Time-Series-Library
+# Modified by Shourya Bose, shbose@ucsc.edu
+
 class AutoCorrelation(nn.Module):
     """
     AutoCorrelation Mechanism with the following two phases:

models/Informer.py

@@ -5,6 +5,9 @@ from math import sqrt
 import numpy as np
 import torch.nn.functional as F
 
+# Modified from: https://github.com/thuml/Time-Series-Library
+# Modified by Shourya Bose, shbose@ucsc.edu
+
 class ConvLayer(nn.Module):
     def __init__(self, c_in):
         super(ConvLayer, self).__init__()

models/LSTM.py

@@ -2,6 +2,8 @@ import torch
 import torch.nn as nn
 from typing import Union, List, Tuple
 
+# Written by Shourya Bose, shbose@ucsc.edu
+
 class LSTM(nn.Module):
     
     def __init__(

models/LSTNet.py

@@ -3,7 +3,8 @@ import torch.nn as nn
 import torch.nn.functional as F
 import numpy as np
 
-# https://github.com/gokulkarthik/LSTNet.pytorch/blob/master/LSTNet.py
+# Modified from https://github.com/gokulkarthik/LSTNet.pytorch/blob/master/LSTNet.py
+# Modified by Shourya Bose, shbose@ucsc.edu
 
 class LSTNet(nn.Module):
     

models/PatchTST.py

@@ -0,0 +1,382 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+import math
+from math import sqrt
+import numpy as np
+
+# Modified from: https://github.com/thuml/Time-Series-Library
+# Modified by Shourya Bose, shbose@ucsc.edu
+
+class PositionalEmbedding(nn.Module):
+    def __init__(self, d_model, max_len=5000):
+        super(PositionalEmbedding, self).__init__()
+        # Compute the positional encodings once in log space.
+        pe = torch.zeros(max_len, d_model).float()
+        pe.require_grad = False
+
+        position = torch.arange(0, max_len).float().unsqueeze(1)
+        div_term = (torch.arange(0, d_model, 2).float()
+                    * -(math.log(10000.0) / d_model)).exp()
+
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+
+        pe = pe.unsqueeze(0)
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        return self.pe[:, :x.size(1)]
+
+class PatchEmbedding(nn.Module):
+    def __init__(self, d_model, patch_len, stride, padding, dropout):
+        super(PatchEmbedding, self).__init__()
+        # Patching
+        self.patch_len = patch_len
+        self.stride = stride
+        self.padding_patch_layer = nn.ReplicationPad1d((0, padding))
+
+        # Backbone, Input encoding: projection of feature vectors onto a d-dim vector space
+        self.value_embedding = nn.Linear(patch_len, d_model, bias=False)
+
+        # Positional embedding
+        self.position_embedding = PositionalEmbedding(d_model)
+
+        # Residual dropout
+        self.dropout = nn.Dropout(dropout)
+
+    def forward(self, x):
+        # do patching
+        n_vars = x.shape[1]
+        x = self.padding_patch_layer(x)
+        x = x.unfold(dimension=-1, size=self.patch_len, step=self.stride)
+        x = torch.reshape(x, (x.shape[0] * x.shape[1], x.shape[2], x.shape[3]))
+        # Input encoding
+        x = self.value_embedding(x) + self.position_embedding(x)
+        return self.dropout(x), n_vars
+
+class AttentionLayer(nn.Module):
+    def __init__(self, attention, d_model, n_heads, d_keys=None,
+                 d_values=None):
+        super(AttentionLayer, self).__init__()
+
+        d_keys = d_keys or (d_model // n_heads)
+        d_values = d_values or (d_model // n_heads)
+
+        self.inner_attention = attention
+        self.query_projection = nn.Linear(d_model, d_keys * n_heads)
+        self.key_projection = nn.Linear(d_model, d_keys * n_heads)
+        self.value_projection = nn.Linear(d_model, d_values * n_heads)
+        self.out_projection = nn.Linear(d_values * n_heads, d_model)
+        self.n_heads = n_heads
+
+    def forward(self, queries, keys, values, attn_mask, tau=None, delta=None):
+        B, L, _ = queries.shape
+        _, S, _ = keys.shape
+        H = self.n_heads
+
+        queries = self.query_projection(queries).view(B, L, H, -1)
+        keys = self.key_projection(keys).view(B, S, H, -1)
+        values = self.value_projection(values).view(B, S, H, -1)
+
+        out, attn = self.inner_attention(
+            queries,
+            keys,
+            values,
+            attn_mask,
+            tau=tau,
+            delta=delta
+        )
+        out = out.view(B, L, -1)
+
+        return self.out_projection(out), attn
+
+class FullAttention(nn.Module):
+    def __init__(self, mask_flag=True, factor=5, scale=None, attention_dropout=0.1, output_attention=False):
+        super(FullAttention, self).__init__()
+        self.scale = scale
+        self.mask_flag = mask_flag
+        self.output_attention = output_attention
+        self.dropout = nn.Dropout(attention_dropout)
+
+    def forward(self, queries, keys, values, attn_mask, tau=None, delta=None):
+        B, L, H, E = queries.shape
+        _, S, _, D = values.shape
+        scale = self.scale or 1. / sqrt(E)
+
+        scores = torch.einsum("blhe,bshe->bhls", queries, keys)
+
+        if self.mask_flag:
+            if attn_mask is None:
+                attn_mask = TriangularCausalMask(B, L, device=queries.device)
+
+            scores.masked_fill_(attn_mask.mask, -np.inf)
+
+        A = self.dropout(torch.softmax(scale * scores, dim=-1))
+        V = torch.einsum("bhls,bshd->blhd", A, values)
+
+        if self.output_attention:
+            return V.contiguous(), A
+        else:
+            return V.contiguous(), None
+
+class TriangularCausalMask():
+    def __init__(self, B, L, device="cpu"):
+        mask_shape = [B, 1, L, L]
+        with torch.no_grad():
+            self._mask = torch.triu(torch.ones(mask_shape, dtype=torch.bool), diagonal=1).to(device)
+
+    @property
+    def mask(self):
+        return self._mask
+
+class FullAttention(nn.Module):
+    def __init__(self, mask_flag=True, factor=5, scale=None, attention_dropout=0.1, output_attention=False):
+        super(FullAttention, self).__init__()
+        self.scale = scale
+        self.mask_flag = mask_flag
+        self.output_attention = output_attention
+        self.dropout = nn.Dropout(attention_dropout)
+
+    def forward(self, queries, keys, values, attn_mask, tau=None, delta=None):
+        B, L, H, E = queries.shape
+        _, S, _, D = values.shape
+        scale = self.scale or 1. / sqrt(E)
+
+        scores = torch.einsum("blhe,bshe->bhls", queries, keys)
+
+        if self.mask_flag:
+            if attn_mask is None:
+                attn_mask = TriangularCausalMask(B, L, device=queries.device)
+
+            scores.masked_fill_(attn_mask.mask, -np.inf)
+
+        A = self.dropout(torch.softmax(scale * scores, dim=-1))
+        V = torch.einsum("bhls,bshd->blhd", A, values)
+
+        if self.output_attention:
+            return V.contiguous(), A
+        else:
+            return V.contiguous(), None
+        
+class AttentionLayer(nn.Module):
+    def __init__(self, attention, d_model, n_heads, d_keys=None,
+                 d_values=None):
+        super(AttentionLayer, self).__init__()
+
+        d_keys = d_keys or (d_model // n_heads)
+        d_values = d_values or (d_model // n_heads)
+
+        self.inner_attention = attention
+        self.query_projection = nn.Linear(d_model, d_keys * n_heads)
+        self.key_projection = nn.Linear(d_model, d_keys * n_heads)
+        self.value_projection = nn.Linear(d_model, d_values * n_heads)
+        self.out_projection = nn.Linear(d_values * n_heads, d_model)
+        self.n_heads = n_heads
+
+    def forward(self, queries, keys, values, attn_mask, tau=None, delta=None):
+        B, L, _ = queries.shape
+        _, S, _ = keys.shape
+        H = self.n_heads
+
+        queries = self.query_projection(queries).view(B, L, H, -1)
+        keys = self.key_projection(keys).view(B, S, H, -1)
+        values = self.value_projection(values).view(B, S, H, -1)
+
+        out, attn = self.inner_attention(
+            queries,
+            keys,
+            values,
+            attn_mask,
+            tau=tau,
+            delta=delta
+        )
+        out = out.view(B, L, -1)
+
+        return self.out_projection(out), attn
+
+class EncoderLayer(nn.Module):
+    def __init__(self, attention, d_model, d_ff=None, dropout=0.1, activation="relu"):
+        super(EncoderLayer, self).__init__()
+        d_ff = d_ff or 4 * d_model
+        self.attention = attention
+        self.conv1 = nn.Conv1d(in_channels=d_model, out_channels=d_ff, kernel_size=1)
+        self.conv2 = nn.Conv1d(in_channels=d_ff, out_channels=d_model, kernel_size=1)
+        self.norm1 = nn.LayerNorm(d_model)
+        self.norm2 = nn.LayerNorm(d_model)
+        self.dropout = nn.Dropout(dropout)
+        self.activation = F.relu if activation == "relu" else F.gelu
+
+    def forward(self, x, attn_mask=None, tau=None, delta=None):
+        new_x, attn = self.attention(
+            x, x, x,
+            attn_mask=attn_mask,
+            tau=tau, delta=delta
+        )
+        x = x + self.dropout(new_x)
+
+        y = x = self.norm1(x)
+        y = self.dropout(self.activation(self.conv1(y.transpose(-1, 1))))
+        y = self.dropout(self.conv2(y).transpose(-1, 1))
+
+        return self.norm2(x + y), attn
+
+
+class Encoder(nn.Module):
+    def __init__(self, attn_layers, conv_layers=None, norm_layer=None):
+        super(Encoder, self).__init__()
+        self.attn_layers = nn.ModuleList(attn_layers)
+        self.conv_layers = nn.ModuleList(conv_layers) if conv_layers is not None else None
+        self.norm = norm_layer
+
+    def forward(self, x, attn_mask=None, tau=None, delta=None):
+        # x [B, L, D]
+        attns = []
+        if self.conv_layers is not None:
+            for i, (attn_layer, conv_layer) in enumerate(zip(self.attn_layers, self.conv_layers)):
+                delta = delta if i == 0 else None
+                x, attn = attn_layer(x, attn_mask=attn_mask, tau=tau, delta=delta)
+                x = conv_layer(x)
+                attns.append(attn)
+            x, attn = self.attn_layers[-1](x, tau=tau, delta=None)
+            attns.append(attn)
+        else:
+            for attn_layer in self.attn_layers:
+                x, attn = attn_layer(x, attn_mask=attn_mask, tau=tau, delta=delta)
+                attns.append(attn)
+
+        if self.norm is not None:
+            x = self.norm(x)
+
+        return x, attns
+
+class Transpose(nn.Module):
+    def __init__(self, *dims, contiguous=False): 
+        super().__init__()
+        self.dims, self.contiguous = dims, contiguous
+    def forward(self, x):
+        if self.contiguous: return x.transpose(*self.dims).contiguous()
+        else: return x.transpose(*self.dims)
+
+
+class FlattenHead(nn.Module):
+    def __init__(self, n_vars, nf, target_window, head_dropout=0):
+        super().__init__()
+        self.n_vars = n_vars
+        self.flatten = nn.Flatten(start_dim=-2)
+        self.linear = nn.Linear(nf, target_window)
+        self.dropout = nn.Dropout(head_dropout)
+
+    def forward(self, x):  # x: [bs x nvars x d_model x patch_num]
+        x = self.flatten(x)
+        x = self.linear(x)
+        x = self.dropout(x)
+        return x
+
+
+class PatchTST(nn.Module):
+    """
+    Paper link: https://arxiv.org/pdf/2211.14730.pdf
+    """
+
+    def __init__(
+        self,
+        enc_in,
+        dec_in, # unused
+        c_out, # unused
+        pred_len,
+        seq_len,
+        d_model = 64,
+        patch_len = 16,
+        stride = 8,
+        data_idx = [0,3,4,5,6,7],
+        time_idx = [1,2],
+        output_attention = False,
+        factor = 3,
+        n_heads = 4,
+        d_ff = 512,
+        e_layers = 3,
+        activation = 'gelu',
+        dropout = 0.1
+    ):
+    
+    #(self, configs, patch_len=16, stride=8):
+        """
+        patch_len: int, patch len for patch_embedding
+        stride: int, stride for patch_embedding
+        """
+        super().__init__()
+        self.seq_len = seq_len
+        self.pred_len = pred_len
+        self.data_idx = data_idx
+        self.time_idx = time_idx
+        self.dec_in = dec_in
+        padding = stride
+
+        # patching and embedding
+        self.patch_embedding = PatchEmbedding(
+            d_model, patch_len, stride, padding, dropout)
+
+        # Encoder
+        self.encoder = Encoder(
+            [
+                EncoderLayer(
+                    AttentionLayer(
+                        FullAttention(False, factor, attention_dropout=dropout,
+                                      output_attention=output_attention), d_model, n_heads),
+                    d_model,
+                    d_ff,
+                    dropout=dropout,
+                    activation=activation
+                ) for l in range(e_layers)
+            ],
+            norm_layer=nn.Sequential(Transpose(1,2), nn.BatchNorm1d(d_model), Transpose(1,2))
+        )
+
+        # Prediction Head
+        self.head_nf = d_model * \
+                       int((seq_len - patch_len) / stride + 2)
+        self.head = FlattenHead(enc_in, self.head_nf,pred_len,
+                                head_dropout=dropout)
+
+    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 - means
+        stdev = torch.sqrt(
+            torch.var(x_enc, dim=1, keepdim=True, unbiased=False) + 1e-5)
+        x_enc /= stdev
+
+        # do patching and embedding
+        x_enc = x_enc.permute(0, 2, 1)
+        # u: [bs * nvars x patch_num x d_model]
+        enc_out, n_vars = self.patch_embedding(x_enc)
+
+        # Encoder
+        # z: [bs * nvars x patch_num x d_model]
+        enc_out, attns = self.encoder(enc_out)
+        # z: [bs x nvars x patch_num x d_model]
+        enc_out = torch.reshape(
+            enc_out, (-1, n_vars, enc_out.shape[-2], enc_out.shape[-1]))
+        # z: [bs x nvars x d_model x patch_num]
+        enc_out = enc_out.permute(0, 1, 3, 2)
+
+        # Decoder
+        dec_out = self.head(enc_out)  # z: [bs x nvars x target_window]
+        dec_out = dec_out.permute(0, 2, 1)
+
+        # De-Normalization from Non-stationary Transformer
+        dec_out = dec_out * \
+                  (stdev[:, 0, :].unsqueeze(1).repeat(1, self.pred_len, 1))
+        dec_out = dec_out + \
+                  (means[:, 0, :].unsqueeze(1).repeat(1, self.pred_len, 1))
+        return dec_out
+    
+    def forward(self, x, fut_time):
+        
+        x_enc = x[:,:,self.data_idx]
+        x_mark_enc = x[:,:,self.time_idx]
+        x_dec = torch.zeros((fut_time.shape[0],fut_time.shape[1],self.dec_in),dtype=fut_time.dtype,device=fut_time.device)
+        x_mark_dec = fut_time
+        
+        return self.forecast(x_enc,x_mark_enc,x_dec,x_mark_dec)[:,-1,[0]]

models/TimesNet.py

@@ -4,6 +4,9 @@ import torch.nn.functional as F
 import torch.fft
 import math
 
+# Modified from: https://github.com/thuml/Time-Series-Library
+# Modified by Shourya Bose, shbose@ucsc.edu
+
 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__()

models/Transformer.py

@@ -5,6 +5,9 @@ import numpy as np
 import math
 from math import sqrt
 
+# Modified from: https://github.com/thuml/Time-Series-Library
+# Modified by Shourya Bose, shbose@ucsc.edu
+
 class TriangularCausalMask():
     def __init__(self, B, L, device="cpu"):
         mask_shape = [B, 1, L, L]

weights/{autoformer_L_96_T_4_HET.pth → Autoformer_L_512_T_48_HET.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:b6ef2bb0c2108017028fc57c70e3f9414f4abb07822ecfaf6d0387ad295a0d32
-size 5688349
+oid sha256:45b9ec43695627b47f4d26af2a2bbd9bb0bd2f0555f500285ee8cdb755a67f2e
+size 5688555

weights/{autoformer_L_96_T_4_HOM.pth → Autoformer_L_512_T_48_HOM.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1233196407b1b89c5f1c1aa69a330b9a11059d14502756c70158f020a29f43d1
-size 5688349
+oid sha256:b29d91943f51b0ef3e21e462a9916a6a98319fa05c980ecca8718c2eaf335cf3
+size 5688555

weights/{autoformer_L_96_T_48_HET.pth → Autoformer_L_512_T_4_HET.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:18a3294861900282c8d001143dd6e61052e294465ddc1b77968cff9464eff7b2
+oid sha256:467f7080dc13b7b35b480d87bc981fcd9de06c22b0b8462dc5bed7d5a4725b02
 size 5688452

weights/{autoformer_L_96_T_48_HOM.pth → Autoformer_L_512_T_4_HOM.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a8ba4d9cc688f64e8456f27286eb2412b844162211a07dd5d93aa9baf13acd69
+oid sha256:a691b1217ad12b7b478d6677d223cbe9ab83582d28d59aabee40634cb308c597
 size 5688452

weights/Autoformer_L_512_T_96_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7127100c4126c3ebd32a547d218fab794a670450bf9bba702578fe9151a45f3b
+size 5688555

weights/Autoformer_L_512_T_96_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d895f416e621fe88ccc24b69ba535ae5143e05ebb7ef6cf44a78a92fc0c5e16d
+size 5688555

weights/Informer_L_512_T_48_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c987dc635ab96659eaf591b3672d02a1e95411ff6b9ac6a83e67e327d70ef545
+size 11244254

weights/Informer_L_512_T_48_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1061956b7c173c0563650f9a99db6b69de0d4c64c676aef361aadc2fb59da8cb
+size 11244254

weights/{informer_L_96_T_48_HET.pth → Informer_L_512_T_4_HET.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ab980f35a30ed0252b268184614bce5981a38d58de69270e8b71d546cf037e66
+oid sha256:e074e56a4441c47c4c67785af771dbe0e043b334c2b2117c1c5dd8db19359119
 size 11244096

weights/{informer_L_96_T_48_HOM.pth → Informer_L_512_T_4_HOM.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5de041c5b3e5476c5e21b2549ed9ef2e42f36ef87f03eb3ea7c8a65ad41f397e
+oid sha256:07df3cfeb077022ead1f47c781578622e1fcd3999aeff63bafd38039c6097898
 size 11244096

weights/Informer_L_512_T_96_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a63fe11c1736668086406b95596331c742ff161eae33d94196dda8bbc46f72c4
+size 11244254

weights/Informer_L_512_T_96_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa6855565c1f3dfa5daef609be1e1d1870537d0a1037ee90b3d06b23e415f70e
+size 11244254

weights/{lstm_L_96_T_48_HET.pth → LSTM_L_512_T_48_HET.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:94291c5486572cee3c7cd2c8c1b7a7415ec97484ca06173cd3a86d500b006df0
-size 57534
+oid sha256:0a2b46b8af8ed52a003dd4b7c1e4a0509292ed47baf8d82300303df5f2f204fc
+size 57440

weights/{lstm_L_96_T_48_HOM.pth → LSTM_L_512_T_48_HOM.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ff835cd72503995f91b3bf7cf2032a102f80472122304258da385d56e2d4e708
-size 57534
+oid sha256:ca040e74faeb12f330047dca6dfd6dd0f9b3a8d37483a2cd201e796c509b8733
+size 57440

weights/{lstm_L_96_T_4_HET.pth → LSTM_L_512_T_4_HET.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4c054d857c774996eef3b0a01225d346bcae05e1cd1de18e88e5b1ea8ec7bca7
-size 57528
+oid sha256:7525980407e8716601da245733432ecaabf3715dfb4f19939ae94795877dc2dd
+size 57434

weights/{lstm_L_96_T_4_HOM.pth → LSTM_L_512_T_4_HOM.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6ee4c4e822c76f72ffda5df510cc938a3808af9e500bcf42746fbcbe53744ec9
-size 57528
+oid sha256:3e853f575c76037be4840217ae2ea1246e64738acf8e5de7b89639fb386136bc
+size 57434

weights/LSTM_L_512_T_96_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8cc82c8363c1ef17b78ac37a5bf2df2700157a9955ac464d2c3e6c101d31e434
+size 57440

weights/LSTM_L_512_T_96_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62a1fb224f362a27d01a020e422bd7a35175e65fe47b5f84de09d1ac2ac1ddaf
+size 57440

weights/LSTNet_L_512_T_48_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e609c6bcb4dddeaf55bef9f0677202fe0fd4d7e54fdb7db4229a5415fd161cfd
+size 269938

weights/LSTNet_L_512_T_48_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6fb46f5ee71399e17c9e3fd3b3f8db8bb9165dc0053703d34c865b7674186983
+size 269938

weights/LSTNet_L_512_T_4_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe29739db58672c03d80e72c4d3487c8c7ec90cb3103345be322019e0e539363
+size 269925

weights/LSTNet_L_512_T_4_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f0d17bafb745f4815fa3220fffec21ef2174acf496b6672c514fdd75f71a3e11
+size 269925

weights/LSTNet_L_512_T_96_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2fb69b81d4a335e78accea202b2c3815d9be0d1122ad88816b13415abc9bd21
+size 269938

weights/LSTNet_L_512_T_96_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca5f9e7018ed5528b8fda0ca7cd25b8f30afe542565937bf17f9e3796e752837
+size 269938

weights/PatchTST_L_512_T_48_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4fb5aa50f43f7a7002432f5a523b330a18f9f749b0795e9d5cc86cbc554cc4b1
+size 6541627

weights/PatchTST_L_512_T_48_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d108041cecfc7cfb86fc1ed640be149d2d5a8e79eb3d38f399ec99de8015b325
+size 6541627

weights/PatchTST_L_512_T_4_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:19cd45f09c45a9848e77976aadcb67587539a270f2d5dc6c1e2510684ef0daed
+size 5099582

weights/PatchTST_L_512_T_4_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cce3f7b3a1f1a2c3177a22fea5f841d740af2dbfc84dc485f8f96cf0ad94ad66
+size 5099582

weights/PatchTST_L_512_T_96_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8f49093c256c1a1e77a02a5d496daffe5abf1eefcbd98672f1fd1cfa7930c6b
+size 8114683

weights/PatchTST_L_512_T_96_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2023748d0cfd6506be324878e5c60e59ff196d1d3fe57ff619fedcafa43be9d2
+size 8114683

weights/TimesNet_L_512_T_48_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:44fa3615ba3e63ff085ead60271bbb5b71e80b597e2ed11fb63d6ee30bf5dc08
+size 5095208

weights/TimesNet_L_512_T_48_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5917eb643874cecd2a1bdfca8b739b746ca2f8afbbcb415abe3c33fa92fdb0d4
+size 5095208

weights/TimesNet_L_512_T_4_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2ab7d8e70ebdc046297d0431c7d04fb80ac4bc594c25df98843eb391960a25f
+size 5004874

weights/TimesNet_L_512_T_4_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55f21a29e4f6832e6df6b674d30a412886d826927e7fa5c83705e4f9a9cae20c
+size 5004874

weights/TimesNet_L_512_T_96_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f81d692ebc490aa6f8b0658b7d330405d3b6598a49eb886ff552642f869604b4
+size 5193704

weights/TimesNet_L_512_T_96_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db49db16f55702204c4e609976c1f24502287facaa7ccbe1bdd9213332c63a48
+size 5193704

weights/Transformer_L_512_T_48_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f79f6cac43d6e7ea9bbce04f5a578111d345a88c1dd84a2badc811901087d3b8
+size 10841738

weights/Transformer_L_512_T_48_HOM.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bc94b53d1dc16a5cc192950ba5885ee00a1dd332425c623cd4b9f8ae5043e876
+size 10841738

weights/{transformer_L_96_T_48_HET.pth → Transformer_L_512_T_4_HET.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9880c6615410fe0beecb62b5744d94f18ea5d54aeaa360fc09bf1b854a383454
+oid sha256:135e67bd5fc9311cc835817be2e9daf41da59909b71771d8f7d3115bc1d0aaa6
 size 10841594

weights/{transformer_L_96_T_48_HOM.pth → Transformer_L_512_T_4_HOM.pth}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:60fde291ab8a817e94efc6b285f3025fb90ee16279c2b148e68743b1edd91e57
+oid sha256:8480ce975178bb82aa429faa2de0e827a7d3ad96416513d500afe858402a635a
 size 10841594

weights/Transformer_L_512_T_96_HET.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa315ca034ddf92ffda0269a961fcc6998b2dec2cacc71294feb0c44d1ba93d8
+size 10841738