SYMBOL INDEX (2458 symbols across 249 files)

FILE: ts_anomaly_detection_methods/anomaly_transformer/ATmodelbatch.py
  class AnomalyAttention (line 17) | class AnomalyAttention(nn.Module):
    method __init__ (line 18) | def __init__(self, N, d_model):
    method forward (line 31) | def forward(self, x):
    method initialize (line 39) | def initialize(self, x):
    method gaussian_kernel (line 46) | def gaussian_kernel(mean, sigma):
    method prior_association (line 50) | def prior_association(self):
    method series_association (line 65) | def series_association(self):
    method reconstruction (line 71) | def reconstruction(self):
  class AnomalyTransformerBlock (line 74) | class AnomalyTransformerBlock(nn.Module):
    method __init__ (line 75) | def __init__(self, N, d_model):
    method forward (line 84) | def forward(self, x):
  class AnomalyTransformer (line 96) | class AnomalyTransformer(nn.Module):
    method __init__ (line 97) | def __init__(self,batch_size, N, in_channel, d_model, layers, lambda_):
    method to_string (line 114) | def to_string(self):
    method forward (line 117) | def forward(self, x):
    method rowwise_kl (line 159) | def rowwise_kl(self, row, Pl, Sl, eps=1e-4):
    method layer_association_discrepancy (line 169) | def layer_association_discrepancy(self, Pl, Sl, x):
    method association_discrepancy (line 175) | def association_discrepancy(self, P_list, S_list, x):
    method loss_function (line 186) | def loss_function(self, x_hat, P_list, S_list, lambda_, x):
    method min_loss (line 196) | def min_loss(self, x):
    method max_loss (line 204) | def max_loss(self, x):
    method anomaly_score_whole (line 211) | def anomaly_score_whole(self, x):
    method anomaly_score (line 229) | def anomaly_score(self, x):

FILE: ts_anomaly_detection_methods/anomaly_transformer/datautils.py
  function load_UCR (line 12) | def load_UCR(dataset):
  function load_anomaly (line 78) | def load_anomaly(name):
  function gen_ano_train_data (line 85) | def gen_ano_train_data(all_train_data):

FILE: ts_anomaly_detection_methods/anomaly_transformer/models/anomaly_transformer_model.py
  class AnomalyAttention (line 7) | class AnomalyAttention(nn.Module):
    method __init__ (line 8) | def __init__(self, N, d_model):
    method forward (line 26) | def forward(self, x):
    method initialize (line 36) | def initialize(self, x):
    method gaussian_kernel (line 43) | def gaussian_kernel(mean, sigma):
    method prior_association (line 47) | def prior_association(self):
    method series_association (line 56) | def series_association(self):
    method reconstruction (line 59) | def reconstruction(self):
  class AnomalyTransformerBlock (line 63) | class AnomalyTransformerBlock(nn.Module):
    method __init__ (line 64) | def __init__(self, N, d_model):
    method forward (line 73) | def forward(self, x):
  class AnomalyTransformer (line 85) | class AnomalyTransformer(nn.Module):
    method __init__ (line 86) | def __init__(self, N, in_channel, d_model, layers, lambda_):
    method forward (line 102) | def forward(self, x):
    method layer_association_discrepancy (line 113) | def layer_association_discrepancy(self, Pl, Sl, x):
    method association_discrepancy (line 122) | def association_discrepancy(self, P_list, S_list, x):
    method loss_function (line 131) | def loss_function(self, x_hat, P_list, S_list, lambda_, x):
    method min_loss (line 138) | def min_loss(self, x):
    method max_loss (line 144) | def max_loss(self, x):
    method anomaly_score (line 150) | def anomaly_score(self, x):

FILE: ts_anomaly_detection_methods/anomaly_transformer/models/dilated_conv.py
  class SamePadConv (line 6) | class SamePadConv(nn.Module):
    method __init__ (line 7) | def __init__(self, in_channels, out_channels, kernel_size, dilation=1,...
    method forward (line 19) | def forward(self, x):
  class ConvBlock (line 25) | class ConvBlock(nn.Module):
    method __init__ (line 26) | def __init__(self, in_channels, out_channels, kernel_size, dilation, f...
    method forward (line 32) | def forward(self, x):
  class DilatedConvEncoder (line 40) | class DilatedConvEncoder(nn.Module):
    method __init__ (line 41) | def __init__(self, in_channels, channels, kernel_size):
    method forward (line 54) | def forward(self, x):

FILE: ts_anomaly_detection_methods/anomaly_transformer/models/encoder.py
  function generate_continuous_mask (line 7) | def generate_continuous_mask(B, T, n=5, l=0.1):
  function generate_binomial_mask (line 23) | def generate_binomial_mask(B, T, p=0.5):
  class TSEncoder (line 26) | class TSEncoder(nn.Module):
    method __init__ (line 27) | def __init__(self, input_dims, output_dims, hidden_dims=64, depth=10, ...
    method forward (line 41) | def forward(self, x, mask=None):  # x: B x T x input_dims

FILE: ts_anomaly_detection_methods/anomaly_transformer/models/losses.py
  function hierarchical_contrastive_loss (line 5) | def hierarchical_contrastive_loss(z1, z2, alpha=0.5, temporal_unit=0):
  function instance_contrastive_loss (line 23) | def instance_contrastive_loss(z1, z2):
  function temporal_contrastive_loss (line 38) | def temporal_contrastive_loss(z1, z2):

FILE: ts_anomaly_detection_methods/anomaly_transformer/tasks/anomaly_detection.py
  function get_range_proba (line 8) | def get_range_proba(predict, label, delay=7):
  function reconstruct_label (line 34) | def reconstruct_label(timestamp, label):
  function eval_ad_result (line 52) | def eval_ad_result(test_pred_list, test_labels_list, test_timestamps_lis...
  function np_shift (line 71) | def np_shift(arr, num, fill_value=np.nan):
  function eval_anomaly_detection (line 84) | def eval_anomaly_detection(model, all_train_data, all_train_labels, all_...
  function eval_anomaly_detection_coldstart (line 162) | def eval_anomaly_detection_coldstart(model, all_train_data, all_train_la...

FILE: ts_anomaly_detection_methods/anomaly_transformer/train.py
  function save_checkpoint_callback (line 14) | def save_checkpoint_callback(

FILE: ts_anomaly_detection_methods/anomaly_transformer/trainATbatch.py
  class Config (line 27) | class Config:
  function train (line 50) | def train(config,model,all_train_data, all_train_labels, all_train_times...
  function evaluate (line 101) | def evaluate(config,cur_epoch,model,all_train_data, all_train_labels, al...
  function main (line 156) | def main(config):

FILE: ts_anomaly_detection_methods/anomaly_transformer/ts2vec.py
  class TS2Vec (line 11) | class TS2Vec:
    method __init__ (line 14) | def __init__(
    method fit (line 61) | def fit(self, train_data, n_epochs=None, n_iters=None, verbose=False):
    method _eval_with_pooling (line 167) | def _eval_with_pooling(self, x, mask=None, slicing=None, encoding_wind...
    method encode (line 211) | def encode(self, data, mask=None, encoding_window=None, casual=False, ...
    method save (line 308) | def save(self, fn):
    method load (line 316) | def load(self, fn):

FILE: ts_anomaly_detection_methods/anomaly_transformer/utils.py
  function pkl_save (line 8) | def pkl_save(name, var):
  function pkl_load (line 12) | def pkl_load(name):
  function split_N_pad (line 16) | def split_N_pad(series,window_size):
  function data_slice (line 32) | def data_slice(data,window_size):
  function torch_pad_nan (line 45) | def torch_pad_nan(arr, left=0, right=0, dim=0):
  function pad_nan_to_target (line 56) | def pad_nan_to_target(array, target_length, axis=0, both_side=False):
  function pad_zero_to_target (line 68) | def pad_zero_to_target(array, target_length, axis=0, both_side=False):
  function split_with_nan (line 80) | def split_with_nan(x, sections, axis=0):
  function take_per_row (line 88) | def take_per_row(A, indx, num_elem):
  function centerize_vary_length_series (line 92) | def centerize_vary_length_series(x):
  function data_dropout (line 101) | def data_dropout(arr, p):
  function name_with_datetime (line 114) | def name_with_datetime(prefix='default'):
  function init_dl_program (line 118) | def init_dl_program(

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/AT_solver.py
  class UniLoader_train (line 29) | class UniLoader_train(object):
    method __init__ (line 30) | def __init__(self, data_set, win_size, step, mode="train"):
    method __len__ (line 38) | def __len__(self):
    method __getitem__ (line 46) | def __getitem__(self, index):
  class UniLoader_test (line 52) | class UniLoader_test(object):
    method __init__ (line 53) | def __init__(self, data_set, label_set, win_size, step, mode="train"):
    method __len__ (line 62) | def __len__(self):
    method __getitem__ (line 70) | def __getitem__(self, index):
  function split_N_pad (line 76) | def split_N_pad(series,window_size):
  function mkdir (line 91) | def mkdir(directory):
  function my_kl_loss (line 96) | def my_kl_loss(p, q):
  function adjust_learning_rate (line 101) | def adjust_learning_rate(optimizer, epoch, lr_):
  class EarlyStopping (line 110) | class EarlyStopping:
    method __init__ (line 111) | def __init__(self, patience=7, verbose=False, dataset_name='', delta=0):
    method __call__ (line 123) | def __call__(self, val_loss, val_loss2, model, path):
    method save_checkpoint (line 141) | def save_checkpoint(self, val_loss, val_loss2, model, path):
  class Solver (line 149) | class Solver(object):
    method __init__ (line 152) | def __init__(self, config, train_set, train_loader, val_set, val_loade...
    method build_model (line 165) | def build_model(self):
    method vali (line 172) | def vali(self, vali_loader):
    method train (line 206) | def train(self):
    method test (line 283) | def test(self, ucr_index=None):
    method train_uni (line 519) | def train_uni(self):
    method test_uni (line 599) | def test_uni(self, all_train_data, all_test_data, all_test_labels, all...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/ATmodelbatch.py
  class AnomalyAttention (line 18) | class AnomalyAttention(nn.Module):
    method __init__ (line 19) | def __init__(self, N, d_model):
    method forward (line 32) | def forward(self, x):
    method initialize (line 40) | def initialize(self, x):
    method gaussian_kernel (line 47) | def gaussian_kernel(mean, sigma):
    method prior_association (line 51) | def prior_association(self):
    method series_association (line 66) | def series_association(self):
    method reconstruction (line 72) | def reconstruction(self):
  class AnomalyTransformerBlock (line 76) | class AnomalyTransformerBlock(nn.Module):
    method __init__ (line 77) | def __init__(self, N, d_model):
    method forward (line 86) | def forward(self, x):
  class AnomalyTransformer (line 99) | class AnomalyTransformer(nn.Module):
    method __init__ (line 100) | def __init__(self, batch_size, N, in_channel, d_model, layers, lambda_):
    method to_string (line 118) | def to_string(self):
    method forward (line 121) | def forward(self, x):
    method rowwise_kl (line 163) | def rowwise_kl(self, row, Pl, Sl, eps=1e-4):
    method layer_association_discrepancy (line 174) | def layer_association_discrepancy(self, Pl, Sl, x):
    method association_discrepancy (line 180) | def association_discrepancy(self, P_list, S_list, x):
    method loss_function (line 191) | def loss_function(self, x_hat, P_list, S_list, lambda_, x):
    method min_loss (line 201) | def min_loss(self, x):
    method max_loss (line 209) | def max_loss(self, x):
    method anomaly_score_whole (line 216) | def anomaly_score_whole(self, x):
    method anomaly_score (line 232) | def anomaly_score(self, x):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/dataset_read_test.py
  function get_range_proba (line 6) | def get_range_proba(predict, label, delay=7):
  function reconstruct_label (line 32) | def reconstruct_label(timestamp, label):
  function eval_ad_result (line 50) | def eval_ad_result(test_pred_list, test_labels_list, test_timestamps_lis...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/datautils.py
  function load_UCR (line 12) | def load_UCR(dataset):
  function load_anomaly (line 78) | def load_anomaly(name):
  function gen_ano_train_data (line 84) | def gen_ano_train_data(all_train_data):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/dcdetector_solver.py
  class UniLoader_train (line 19) | class UniLoader_train(object):
    method __init__ (line 20) | def __init__(self, data_set, win_size, step, mode="train"):
    method __len__ (line 28) | def __len__(self):
    method __getitem__ (line 36) | def __getitem__(self, index):
  class UniLoader_test (line 42) | class UniLoader_test(object):
    method __init__ (line 43) | def __init__(self, data_set, label_set, win_size, step, mode="train"):
    method __len__ (line 52) | def __len__(self):
    method __getitem__ (line 60) | def __getitem__(self, index):
  function my_kl_loss (line 68) | def my_kl_loss(p, q):
  function adjust_learning_rate (line 73) | def adjust_learning_rate(optimizer, epoch, lr_):
  class EarlyStopping (line 81) | class EarlyStopping:
    method __init__ (line 82) | def __init__(self, patience=7, verbose=False, dataset_name='', delta=0...
    method __call__ (line 95) | def __call__(self, val_loss, val_loss2, model, path):
    method save_checkpoint (line 112) | def save_checkpoint(self, val_loss, val_loss2, model, path):
  class Solver (line 119) | class Solver(object):
    method __init__ (line 122) | def __init__(self, config, multi=True):
    method build_model (line 150) | def build_model(self):
    method vali (line 160) | def vali(self, vali_loader):
    method train (line 192) | def train(self):
    method test (line 263) | def test(self, ucr_index=None):
    method vali_uni (line 481) | def vali_uni(self, vali_loader):
    method train_uni (line 513) | def train_uni(self):
    method test_uni (line 584) | def test_uni(self, all_train_data, all_test_data, all_test_labels, all...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/donut.py
  function adjustment (line 18) | def adjustment(gt, pred):
  class DONUT (line 42) | class DONUT:
    method __init__ (line 44) | def __init__(
    method train (line 76) | def train(self, train_data, n_epochs=None, n_iters=None, verbose=False):
    method anomaly_score (line 168) | def anomaly_score(self, model, test_data, is_multi=False):
    method evaluate (line 225) | def evaluate(self, model, all_train_data, all_train_labels, all_train_...
    method save (line 353) | def save(self, fn):
    method load (line 361) | def load(self, fn):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/exp_anomaly_detection.py
  class UniLoader_train (line 27) | class UniLoader_train(object):
    method __init__ (line 28) | def __init__(self, data_set, win_size, step, mode="train"):
    method __len__ (line 36) | def __len__(self):
    method __getitem__ (line 44) | def __getitem__(self, index):
  class UniLoader_test (line 50) | class UniLoader_test(object):
    method __init__ (line 51) | def __init__(self, data_set, label_set, win_size, step, mode="train"):
    method __len__ (line 60) | def __len__(self):
    method __getitem__ (line 68) | def __getitem__(self, index):
  function adjustment (line 76) | def adjustment(gt, pred):
  function adjust_learning_rate (line 100) | def adjust_learning_rate(optimizer, epoch, args):
  class EarlyStopping (line 118) | class EarlyStopping:
    method __init__ (line 119) | def __init__(self, patience=7, verbose=False, delta=0):
    method __call__ (line 128) | def __call__(self, val_loss, model, path):
    method save_checkpoint (line 143) | def save_checkpoint(self, val_loss, model, path):
  class Exp_Basic (line 149) | class Exp_Basic(object):
    method __init__ (line 150) | def __init__(self, args):
    method _build_model (line 159) | def _build_model(self):
    method _acquire_device (line 163) | def _acquire_device(self):
    method _get_data (line 174) | def _get_data(self):
    method vali (line 177) | def vali(self):
    method train (line 180) | def train(self):
    method test (line 183) | def test(self):
  class Exp_Anomaly_Detection (line 187) | class Exp_Anomaly_Detection(Exp_Basic):
    method __init__ (line 188) | def __init__(self, args, train_set, train_loader, val_set, val_loader,...
    method _build_model (line 197) | def _build_model(self):
    method _get_data (line 204) | def _get_data(self, flag):
    method _select_optimizer (line 217) | def _select_optimizer(self):
    method _select_criterion (line 221) | def _select_criterion(self):
    method vali (line 225) | def vali(self, vali_data, vali_loader, criterion):
    method vali_uni (line 245) | def vali_uni(self, vali_data, vali_loader, criterion):
    method train (line 265) | def train(self, setting):
    method train_uni (line 333) | def train_uni(self, setting):
    method test (line 403) | def test(self, setting, test=0, dataset=None, ucr_index=None):
    method test_uni (line 551) | def test_uni(self, setting, all_train_data, all_test_data, all_test_la...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/lstm_vae.py
  function adjustment (line 18) | def adjustment(gt, pred):
  class LSTM_VAE (line 42) | class LSTM_VAE:
    method __init__ (line 44) | def __init__(
    method train (line 76) | def train(self, train_data, n_epochs=None, n_iters=None, verbose=False):
    method anomaly_score (line 168) | def anomaly_score(self, model, test_data, is_multi=False):
    method evaluate (line 188) | def evaluate(self, model, all_train_data, all_train_labels, all_train_...
    method save (line 315) | def save(self, fn):
    method load (line 323) | def load(self, fn):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/AUC.py
  function extend_postive_range (line 8) | def extend_postive_range(x, window=16):
  function extend_postive_range_individual (line 28) | def extend_postive_range_individual(x, percentage=0.2):
  function TPR_FPR_RangeAUC (line 48) | def TPR_FPR_RangeAUC(labels, pred, P, L):
  function Range_AUC (line 84) | def Range_AUC(score_t_test, y_test,  window=5, percentage=0, plot_ROC=Fa...
  function point_wise_AUC (line 134) | def point_wise_AUC(score_t_test, y_test,  plot_ROC=False):
  function main (line 149) | def main():

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/Matthews_correlation_coefficient.py
  function MCC (line 5) | def MCC(y_test, pred_labels):
  function main (line 12) | def main():

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/affiliation/_affiliation_zone.py
  function t_start (line 5) | def t_start(j, Js = [(1,2),(3,4),(5,6)], Trange = (1,10)):
  function t_stop (line 22) | def t_stop(j, Js = [(1,2),(3,4),(5,6)], Trange = (1,10)):
  function E_gt_func (line 38) | def E_gt_func(j, Js, Trange):
  function get_all_E_gt_func (line 53) | def get_all_E_gt_func(Js, Trange):
  function affiliation_partition (line 66) | def affiliation_partition(Is = [(1,1.5),(2,5),(5,6),(8,9)], E_gt = [(1,2...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/affiliation/_integral_interval.py
  function interval_length (line 14) | def interval_length(J = (1,2)):
  function sum_interval_lengths (line 25) | def sum_interval_lengths(Is = [(1,2),(3,4),(5,6)]):
  function interval_intersection (line 34) | def interval_intersection(I = (1, 3), J = (2, 4)):
  function interval_subset (line 54) | def interval_subset(I = (1, 3), J = (0, 6)):
  function cut_into_three_func (line 67) | def cut_into_three_func(I, J):
  function get_pivot_j (line 104) | def get_pivot_j(I, J):
  function integral_mini_interval (line 125) | def integral_mini_interval(I, J):
  function integral_interval_distance (line 144) | def integral_interval_distance(I, J):
  function integral_mini_interval_P_CDFmethod__min_piece (line 177) | def integral_mini_interval_P_CDFmethod__min_piece(I, J, E):
  function integral_mini_interval_Pprecision_CDFmethod (line 213) | def integral_mini_interval_Pprecision_CDFmethod(I, J, E):
  function integral_interval_probaCDF_precision (line 244) | def integral_interval_probaCDF_precision(I, J, E):
  function cut_J_based_on_mean_func (line 281) | def cut_J_based_on_mean_func(J, e_mean):
  function integral_mini_interval_Precall_CDFmethod (line 306) | def integral_mini_interval_Precall_CDFmethod(I, J, E):
  function integral_interval_probaCDF_recall (line 422) | def integral_interval_probaCDF_recall(I, J, E):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/affiliation/_single_ground_truth_event.py
  function affiliation_precision_distance (line 14) | def affiliation_precision_distance(Is = [(1,2),(3,4),(5,6)], J = (2,5.5)):
  function affiliation_precision_proba (line 26) | def affiliation_precision_proba(Is = [(1,2),(3,4),(5,6)], J = (2,5.5), E...
  function affiliation_recall_distance (line 39) | def affiliation_recall_distance(Is = [(1,2),(3,4),(5,6)], J = (2,5.5)):
  function affiliation_recall_proba (line 54) | def affiliation_recall_proba(Is = [(1,2),(3,4),(5,6)], J = (2,5.5), E = ...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/affiliation/generics.py
  function convert_vector_to_events (line 10) | def convert_vector_to_events(vector = [0, 1, 1, 0, 0, 1, 0]):
  function infer_Trange (line 34) | def infer_Trange(events_pred, events_gt):
  function has_point_anomalies (line 59) | def has_point_anomalies(events):
  function _sum_wo_nan (line 71) | def _sum_wo_nan(vec):
  function _len_wo_nan (line 81) | def _len_wo_nan(vec):
  function read_gz_data (line 91) | def read_gz_data(filename = 'data/machinetemp_groundtruth.gz'):
  function read_all_as_events (line 104) | def read_all_as_events():
  function f1_func (line 129) | def f1_func(p, r):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/affiliation/metrics.py
  function test_events (line 18) | def test_events(events):
  function pr_from_events (line 35) | def pr_from_events(events_pred, events_gt, Trange):
  function produce_all_results (line 98) | def produce_all_results():

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/combine_all_scores.py
  function combine_all_evaluation_scores (line 14) | def combine_all_evaluation_scores(y_test, pred_labels, anomaly_scores):
  function main (line 55) | def main():

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/customizable_f1_score.py
  function b (line 7) | def b(bias, i, length):
  function w (line 21) | def w(AnomalyRange, p):
  function Cardinality_factor (line 36) | def Cardinality_factor(Anomolyrange, Prange):
  function existence_reward (line 55) | def existence_reward(labels, preds):
  function range_recall_new (line 68) | def range_recall_new(labels, preds, alpha):
  function customizable_f1_score (line 88) | def customizable_f1_score(y_test, pred_labels,  alpha=0.2):
  function main (line 101) | def main():

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/evaluate_utils.py
  function get_composite_fscore_from_scores (line 6) | def get_composite_fscore_from_scores(score_t_test, thres, true_events, p...
  class NptConfig (line 19) | class NptConfig:
    method __init__ (line 20) | def __init__(self, config_dict):
  function find_length (line 24) | def find_length(data):
  function range_convers_new (line 42) | def range_convers_new(label):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/evaluator.py
  function evaluate (line 20) | def evaluate(saved_model_root, logger, thres_methods=["top_k_time", "bes...
  function analyse_from_pkls (line 317) | def analyse_from_pkls(results_root:str, thres_methods=["best_f1_test"], ...
  function repredict_from_saved_model (line 427) | def repredict_from_saved_model(model_root, algo_class, entity, logger):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/f1_score_f1_pa.py
  function get_point_adjust_scores (line 7) | def get_point_adjust_scores(y_test, pred_labels, true_events, thereshold...
  function get_adjust_F1PA (line 27) | def get_adjust_F1PA(pred, gt):
  function get_prec_rec_fscore (line 59) | def get_prec_rec_fscore(tp, fp, fn):
  function get_f_score (line 70) | def get_f_score(prec, rec):
  function get_accuracy_precision_recall_fscore (line 79) | def get_accuracy_precision_recall_fscore(y_true: list, y_pred: list):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/f1_series.py
  function threshold_and_predict (line 19) | def threshold_and_predict(score_t_test, y_test, true_events, logger, tes...
  function evaluate_predicted_labels (line 92) | def evaluate_predicted_labels(pred_labels, y_test, true_events, logger, ...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/fc_score.py
  function get_events (line 5) | def get_events(y_test, outlier=1, normal=0):
  function get_composite_fscore_raw (line 27) | def get_composite_fscore_raw(y_test, pred_labels,  true_events, return_p...
  function main (line 40) | def main():

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/metrics.py
  function combine_all_evaluation_scores (line 13) | def combine_all_evaluation_scores(y_test, pred_labels, anomaly_scores):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/precision_at_k.py
  function precision_at_k (line 6) | def precision_at_k(y_test, score_t_test, pred_labels):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/vus/analysis/robustness_eval.py
  function generate_new_label (line 26) | def generate_new_label(label,lag):
  function compute_anomaly_acc_lag (line 34) | def compute_anomaly_acc_lag(methods_scores,label,slidingWindow,methods_k...
  function compute_anomaly_acc_percentage (line 87) | def compute_anomaly_acc_percentage(methods_scores,label,slidingWindow,me...
  function compute_anomaly_acc_noise (line 150) | def compute_anomaly_acc_noise(methods_scores,label,slidingWindow,methods...
  function compute_anomaly_acc_pairwise (line 208) | def compute_anomaly_acc_pairwise(methods_scores,label,slidingWindow,meth...
  function normalize_dict_exp (line 270) | def normalize_dict_exp(methods_acc_lag,methods_keys):
  function group_dict (line 296) | def group_dict(methods_acc_lag,methods_keys):
  function generate_curve (line 322) | def generate_curve(label,score,slidingWindow):
  function box_plot (line 334) | def box_plot(data, edge_color, fill_color):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/vus/analysis/score_computation.py
  function find_section_length (line 35) | def find_section_length(label,length):
  function generate_data (line 67) | def generate_data(filepath,init_pos,max_length):
  function compute_score (line 92) | def compute_score(methods,slidingWindow,data,X_data,data_train,data_test...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/vus/metrics.py
  function get_range_vus_roc (line 5) | def get_range_vus_roc(score, labels, slidingWindow):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/vus/models/distance.py
  class Euclidean (line 20) | class Euclidean:
    method __init__ (line 40) | def __init__(self, power = 1, neighborhood = 100, window = 20, norm = ...
    method measure (line 48) | def measure(self, X, Y, index):
    method set_param (line 100) | def set_param(self):
  class Mahalanobis (line 111) | class Mahalanobis:
    method __init__ (line 129) | def __init__(self, probability = False):
    method set_param (line 135) | def set_param(self):
    method norm_pdf_multivariate (line 154) | def norm_pdf_multivariate(self, x):
    method normpdf (line 175) | def normpdf(self, x):
    method measure (line 185) | def measure(self, X, Y, index):
  class Garch (line 226) | class Garch:
    method __init__ (line 245) | def __init__(self, p = 1, q = 1, mean = 'zero', vol = 'garch'):
    method set_param (line 252) | def set_param(self):
    method measure (line 273) | def measure(self, X, Y, index):
  class SSA_DISTANCE (line 302) | class SSA_DISTANCE:
    method __init__ (line 320) | def __init__(self, method ='linear', e = 1):
    method Linearization (line 324) | def Linearization(self, X2):
    method set_param (line 363) | def set_param(self):
    method measure (line 371) | def measure(self, X2, X3, start_index):
  class Fourier (line 428) | class Fourier:
    method __init__ (line 444) | def __init__(self, power = 2):
    method set_param (line 447) | def set_param(self):
    method measure (line 455) | def measure(self, X2, X3, start_index):
  class DTW (line 483) | class DTW:
    method __init__ (line 500) | def __init__(self, method = 'L2'):
    method set_param (line 510) | def set_param(self):
    method measure (line 518) | def measure(self, X1, X2, start_index):
  class EDRS (line 589) | class EDRS:
    method __init__ (line 611) | def __init__(self, method = 'L1', ep = False, vol = False):
    method set_param (line 621) | def set_param(self):
    method measure (line 647) | def measure(self, X1, X2, start_index):
  class TWED (line 733) | class TWED:
    method __init__ (line 754) | def __init__(self, gamma = 0.1, v = 0.1):
    method set_param (line 759) | def set_param(self):
    method measure (line 763) | def measure(self, A, B, start_index):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/vus/models/feature.py
  class Window (line 43) | class Window:
    method __init__ (line 49) | def __init__(self,  window = 100):
    method convert (line 52) | def convert(self, X):
  class tf_Stat (line 65) | class tf_Stat:
    method __init__ (line 74) | def __init__(self,  window = 100, step = 25):
    method convert (line 78) | def convert(self, X):
  class Stat (line 108) | class Stat:
    method __init__ (line 114) | def __init__(self,  window = 100, data_step = 10, param = [{"coeff": 0...
    method convert (line 125) | def convert(self, X):
    method ar_coefficient (line 186) | def ar_coefficient(self, x):
    method autocorrelation (line 241) | def autocorrelation(self, x):
    method _into_subchunks (line 283) | def _into_subchunks(self, x, subchunk_length, every_n=1):
    method sample_entropy (line 307) | def sample_entropy(self, x):
    method hurst_f (line 357) | def hurst_f(self, x):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/vus/utils/metrics.py
  class metricor (line 6) | class metricor:
    method __init__ (line 7) | def __init__(self, a = 1, probability = True, bias = 'flat', ):
    method detect_model (line 12) | def detect_model(self, model, label, contamination = 0.1, window = 100...
    method labels_conv (line 28) | def labels_conv(self, preds):
    method labels_conv_binary (line 36) | def labels_conv_binary(self, preds):
    method w (line 45) | def w(self, AnomalyRange, p):
    method Cardinality_factor (line 57) | def Cardinality_factor(self, Anomolyrange, Prange):
    method b (line 75) | def b(self, i, length):
    method scale_threshold (line 90) | def scale_threshold(self, score, score_mu, score_sigma):
    method metric_new (line 94) | def metric_new(self, label, score, plot_ROC=False, alpha=0.2,coeff=3):
    method metric_PR (line 161) | def metric_PR(self, label, score):
    method range_recall_new (line 170) | def range_recall_new(self, labels, preds, alpha):
    method range_convers_new (line 193) | def range_convers_new(self, label):
    method existence_reward (line 225) | def existence_reward(self, labels, preds):
    method num_nonzero_segments (line 237) | def num_nonzero_segments(self, x):
    method extend_postive_range (line 246) | def extend_postive_range(self, x, window=5):
    method extend_postive_range_individual (line 264) | def extend_postive_range_individual(self, x, percentage=0.2):
    method TPR_FPR_RangeAUC (line 283) | def TPR_FPR_RangeAUC(self, labels, pred, P, L):
    method RangeAUC (line 322) | def RangeAUC(self, labels, score, window=0, percentage=0, plot_ROC=Fal...
    method RangeAUC_volume (line 371) | def RangeAUC_volume(self, labels_original, score, windowSize):
  function generate_curve (line 431) | def generate_curve(label,score,slidingWindow):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/metrics/vus/utils/slidingWindows.py
  function find_length (line 8) | def find_length(data):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/models/AnomalyTransformer.py
  class PositionalEmbedding (line 12) | class PositionalEmbedding(nn.Module):
    method __init__ (line 13) | def __init__(self, d_model, max_len=5000):
    method forward (line 28) | def forward(self, x):
  class TokenEmbedding (line 32) | class TokenEmbedding(nn.Module):
    method __init__ (line 33) | def __init__(self, c_in, d_model):
    method forward (line 42) | def forward(self, x):
  class DataEmbedding (line 47) | class DataEmbedding(nn.Module):
    method __init__ (line 48) | def __init__(self, c_in, d_model, dropout=0.0):
    method forward (line 56) | def forward(self, x):
  class TriangularCausalMask (line 62) | class TriangularCausalMask():
    method __init__ (line 63) | def __init__(self, B, L, device="cpu"):
    method mask (line 69) | def mask(self):
  class AnomalyAttention (line 73) | class AnomalyAttention(nn.Module):
    method __init__ (line 74) | def __init__(self, win_size, mask_flag=True, scale=None, attention_dro...
    method forward (line 87) | def forward(self, queries, keys, values, sigma, attn_mask):
  class AttentionLayer (line 116) | class AttentionLayer(nn.Module):
    method __init__ (line 117) | def __init__(self, attention, d_model, n_heads, d_keys=None,
    method forward (line 137) | def forward(self, queries, keys, values, attn_mask):
  class EncoderLayer (line 160) | class EncoderLayer(nn.Module):
    method __init__ (line 161) | def __init__(self, attention, d_model, d_ff=None, dropout=0.1, activat...
    method forward (line 172) | def forward(self, x, attn_mask=None):
  class Encoder (line 185) | class Encoder(nn.Module):
    method __init__ (line 186) | def __init__(self, attn_layers, norm_layer=None):
    method forward (line 191) | def forward(self, x, attn_mask=None):
  class AnomalyTransformer (line 208) | class AnomalyTransformer(nn.Module):
    method __init__ (line 209) | def __init__(self, win_size, enc_in, c_out, d_model=512, n_heads=8, e_...
    method forward (line 235) | def forward(self, x):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/models/DCdetector.py
  class DAC_structure (line 21) | class DAC_structure(nn.Module):
    method __init__ (line 22) | def __init__(self, win_size, patch_size, channel, mask_flag=True, scal...
    method forward (line 33) | def forward(self, queries_patch_size, queries_patch_num, keys_patch_si...
  class AttentionLayer (line 66) | class AttentionLayer(nn.Module):
    method __init__ (line 67) | def __init__(self, attention, d_model, patch_size, channel, n_heads, w...
    method forward (line 84) | def forward(self, x_patch_size, x_patch_num, x_ori, patch_index, attn_...
  class PositionalEmbedding (line 112) | class PositionalEmbedding(nn.Module):
    method __init__ (line 113) | def __init__(self, d_model, max_len=5000):
    method forward (line 128) | def forward(self, x):
  class TokenEmbedding (line 132) | class TokenEmbedding(nn.Module):
    method __init__ (line 133) | def __init__(self, c_in, d_model):
    method forward (line 142) | def forward(self, x):
  class DataEmbedding (line 147) | class DataEmbedding(nn.Module):
    method __init__ (line 148) | def __init__(self, c_in, d_model, dropout=0.05):
    method forward (line 156) | def forward(self, x):
  class RevIN (line 161) | class RevIN(nn.Module):
    method __init__ (line 162) | def __init__(self, num_features: int, eps=1e-5, affine=True):
    method forward (line 175) | def forward(self, x, mode: str):
    method _init_params (line 185) | def _init_params(self):
    method _get_statistics (line 193) | def _get_statistics(self, x):
    method _normalize (line 198) | def _normalize(self, x):
    method _denormalize (line 206) | def _denormalize(self, x):
  class Encoder (line 215) | class Encoder(nn.Module):
    method __init__ (line 216) | def __init__(self, attn_layers, norm_layer=None):
    method forward (line 221) | def forward(self, x_patch_size, x_patch_num, x_ori, patch_index, attn_...
  class DCdetector (line 231) | class DCdetector(nn.Module):
    method __init__ (line 232) | def __init__(self, win_size, enc_in, c_out, n_heads=1, d_model=256, e_...
    method forward (line 262) | def forward(self, x):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/models/GPT4TS.py
  class PositionalEmbedding (line 11) | class PositionalEmbedding(nn.Module):
    method __init__ (line 12) | def __init__(self, d_model, max_len=5000):
    method forward (line 28) | def forward(self, x):
  class TokenEmbedding (line 32) | class TokenEmbedding(nn.Module):
    method __init__ (line 33) | def __init__(self, c_in, d_model):
    method forward (line 43) | def forward(self, x):
  class FixedEmbedding (line 48) | class FixedEmbedding(nn.Module):
    method __init__ (line 49) | def __init__(self, c_in, d_model):
    method forward (line 65) | def forward(self, x):
  class TemporalEmbedding (line 69) | class TemporalEmbedding(nn.Module):
    method __init__ (line 70) | def __init__(self, d_model, embed_type='fixed', freq='h'):
    method forward (line 87) | def forward(self, x):
  class TimeFeatureEmbedding (line 99) | class TimeFeatureEmbedding(nn.Module):
    method __init__ (line 100) | def __init__(self, d_model, embed_type='timeF', freq='h'):
    method forward (line 108) | def forward(self, x):
  class DataEmbedding (line 112) | class DataEmbedding(nn.Module):
    method __init__ (line 113) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 123) | def forward(self, x, x_mark):
  class DataEmbedding_wo_pos (line 132) | class DataEmbedding_wo_pos(nn.Module):
    method __init__ (line 133) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 143) | def forward(self, x, x_mark):
  class Model (line 150) | class Model(nn.Module):
    method __init__ (line 152) | def __init__(self, configs):
    method forward (line 217) | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):
    method imputation (line 233) | def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask):
    method forecast (line 261) | def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
    method anomaly_detection (line 302) | def anomaly_detection(self, x_enc):
    method classification (line 350) | def classification(self, x_enc, x_mark_enc):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/models/TimesNet.py
  class Inception_Block_V1 (line 8) | class Inception_Block_V1(nn.Module):
    method __init__ (line 9) | def __init__(self, in_channels, out_channels, num_kernels=6, init_weig...
    method _initialize_weights (line 21) | def _initialize_weights(self):
    method forward (line 28) | def forward(self, x):
  class PositionalEmbedding (line 36) | class PositionalEmbedding(nn.Module):
    method __init__ (line 37) | def __init__(self, d_model, max_len=5000):
    method forward (line 53) | def forward(self, x):
  class TokenEmbedding (line 57) | class TokenEmbedding(nn.Module):
    method __init__ (line 58) | def __init__(self, c_in, d_model):
    method forward (line 68) | def forward(self, x):
  class FixedEmbedding (line 73) | class FixedEmbedding(nn.Module):
    method __init__ (line 74) | def __init__(self, c_in, d_model):
    method forward (line 90) | def forward(self, x):
  class TemporalEmbedding (line 94) | class TemporalEmbedding(nn.Module):
    method __init__ (line 95) | def __init__(self, d_model, embed_type='fixed', freq='h'):
    method forward (line 112) | def forward(self, x):
  class TimeFeatureEmbedding (line 124) | class TimeFeatureEmbedding(nn.Module):
    method __init__ (line 125) | def __init__(self, d_model, embed_type='timeF', freq='h'):
    method forward (line 133) | def forward(self, x):
  class DataEmbedding (line 137) | class DataEmbedding(nn.Module):
    method __init__ (line 138) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 148) | def forward(self, x, x_mark):
  function FFT_for_Period (line 158) | def FFT_for_Period(x, k=2):
  class TimesBlock (line 170) | class TimesBlock(nn.Module):
    method __init__ (line 171) | def __init__(self, configs):
    method forward (line 185) | def forward(self, x):
  class Model (line 220) | class Model(nn.Module):
    method __init__ (line 225) | def __init__(self, configs):
    method forecast (line 252) | def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
    method imputation (line 279) | def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask):
    method anomaly_detection (line 307) | def anomaly_detection(self, x_enc):
    method classification (line 332) | def classification(self, x_enc, x_mark_enc):
    method forward (line 350) | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/models/dilated_conv.py
  class SamePadConv (line 6) | class SamePadConv(nn.Module):
    method __init__ (line 7) | def __init__(self, in_channels, out_channels, kernel_size, dilation=1,...
    method forward (line 19) | def forward(self, x):
  class ConvBlock (line 25) | class ConvBlock(nn.Module):
    method __init__ (line 26) | def __init__(self, in_channels, out_channels, kernel_size, dilation, f...
    method forward (line 32) | def forward(self, x):
  class DilatedConvEncoder (line 40) | class DilatedConvEncoder(nn.Module):
    method __init__ (line 41) | def __init__(self, in_channels, channels, kernel_size):
    method forward (line 54) | def forward(self, x):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/models/donut_model.py
  class VariationalNet (line 6) | class VariationalNet(nn.Module):
    method __init__ (line 11) | def __init__(self, in_channel, latent_dim=100, hidden_dim=3):
    method forward (line 30) | def forward(self, inputs):
  class GenerativeNet (line 45) | class GenerativeNet(nn.Module):
    method __init__ (line 50) | def __init__(self, in_channel, latent_dim=100, hidden_dim=3):
    method forward (line 69) | def forward(self, z):
  class DONUT_Model (line 84) | class DONUT_Model(nn.Module):
    method __init__ (line 86) | def __init__(self, in_channel, latent_dim=100, hidden_dim=3):
    method reparameterize (line 97) | def reparameterize(self, mu, logvar):
    method forward (line 109) | def forward(self, inputs):
    method loss_function (line 126) | def loss_function(self, inputs, outputs, z_mu, z_log_var, x_mu, x_log_...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/models/encoder.py
  function generate_continuous_mask (line 7) | def generate_continuous_mask(B, T, n=5, l=0.1):
  function generate_binomial_mask (line 23) | def generate_binomial_mask(B, T, p=0.5):
  class TSEncoder (line 26) | class TSEncoder(nn.Module):
    method __init__ (line 27) | def __init__(self, input_dims, output_dims, hidden_dims=64, depth=10, ...
    method forward (line 41) | def forward(self, x, mask=None):  # x: B x T x input_dims

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/models/losses.py
  function hierarchical_contrastive_loss (line 5) | def hierarchical_contrastive_loss(z1, z2, alpha=0.5, temporal_unit=0):
  function instance_contrastive_loss (line 23) | def instance_contrastive_loss(z1, z2):
  function temporal_contrastive_loss (line 38) | def temporal_contrastive_loss(z1, z2):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/models/lstm_vae_model.py
  class LSTM_Encoder (line 6) | class LSTM_Encoder(nn.Module):
    method __init__ (line 11) | def __init__(self, device, in_channel, hidden_size=16, hidden_dim=3):
    method forward (line 26) | def forward(self, inputs):
  class LSTM_Decoder (line 46) | class LSTM_Decoder(nn.Module):
    method __init__ (line 51) | def __init__(self, device, in_channel, hidden_size=16, hidden_dim=3):
    method forward (line 66) | def forward(self, z):
  class LSTM_VAE_Model (line 86) | class LSTM_VAE_Model(nn.Module):
    method __init__ (line 88) | def __init__(self, device, in_channel, hidden_size=16, hidden_dim=3):
    method reparameterize (line 100) | def reparameterize(self, mu, logvar):
    method forward (line 112) | def forward(self, inputs):
    method loss_function (line 129) | def loss_function(self, inputs, outputs, z_mu, z_log_var, x_mu, x_log_...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/spot.py
  class SPOT (line 27) | class SPOT:
    method __init__ (line 58) | def __init__(self, q = 1e-4):
    method __str__ (line 80) | def __str__(self):
    method fit (line 109) | def fit(self,init_data,data):
    method add (line 150) | def add(self,data):
    method initialize (line 172) | def initialize(self, level = 0.98, verbose = True):
    method _rootsFinder (line 215) | def _rootsFinder(fun,jac,bounds,npoints,method):
    method _log_likelihood (line 272) | def _log_likelihood(Y,gamma,sigma):
    method _grimshaw (line 299) | def _grimshaw(self,epsilon = 1e-8, n_points = 10):
    method _quantile (line 382) | def _quantile(self,gamma,sigma):
    method run (line 405) | def run(self, with_alarm = True):
    method plot (line 472) | def plot(self,run_results,with_alarm = True):
  function backMean (line 517) | def backMean(X,d):
  class dSPOT (line 528) | class dSPOT:
    method __init__ (line 561) | def __init__(self, q, depth):
    method __str__ (line 572) | def __str__(self):
    method fit (line 602) | def fit(self,init_data,data):
    method add (line 642) | def add(self,data):
    method initialize (line 664) | def initialize(self, verbose = True):
    method _rootsFinder (line 706) | def _rootsFinder(fun,jac,bounds,npoints,method):
    method _log_likelihood (line 754) | def _log_likelihood(Y,gamma,sigma):
    method _grimshaw (line 781) | def _grimshaw(self,epsilon = 1e-8, n_points = 10):
    method _quantile (line 864) | def _quantile(self,gamma,sigma):
    method run (line 887) | def run(self, with_alarm = True):
    method plot (line 960) | def plot(self,run_results, with_alarm = True):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/tasks/anomaly_detection.py
  function get_range_proba (line 17) | def get_range_proba(predict, label, delay=7):
  function get_range_proba (line 43) | def get_range_proba(predict, label, delay=7):
  function reconstruct_label (line 69) | def reconstruct_label(timestamp, label):
  function eval_ad_result (line 87) | def eval_ad_result(test_pred_list, test_labels_list, test_timestamps_lis...
  function np_shift (line 158) | def np_shift(arr, num, fill_value=np.nan):
  function adjustment (line 171) | def adjustment(gt, pred):
  function eval_anomaly_detection (line 195) | def eval_anomaly_detection(model, all_train_data, all_train_labels, all_...
  function eval_anomaly_detection_coldstart (line 426) | def eval_anomaly_detection_coldstart(model, all_train_data, all_train_la...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train.py
  function save_checkpoint_callback (line 13) | def save_checkpoint_callback(

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/trainATbatch.py
  function get_range_proba (line 24) | def get_range_proba(predict, label, delay=7):
  class Config (line 56) | class Config:
  function train (line 78) | def train(config, model, all_train_data, all_train_labels, all_train_tim...
  function np_shift (line 132) | def np_shift(arr, num, fill_value=np.nan):
  function reconstruct_label (line 146) | def reconstruct_label(timestamp, label):
  function eval_ad_result (line 164) | def eval_ad_result(test_pred_list, test_labels_list, test_timestamps_lis...
  function evaluate (line 183) | def evaluate(config, cur_epoch, model, all_train_data, all_train_labels,...
  function main (line 243) | def main(config):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_at_multi.py
  function str2bool (line 22) | def str2bool(v):
  function main (line 26) | def main(config, train_set, train_loader, val_set, val_loader, test_set,...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_at_uni.py
  class UniLoader (line 24) | class UniLoader(object):
    method __init__ (line 25) | def __init__(self, data_set, win_size, step, mode="train"):
    method __len__ (line 33) | def __len__(self):
    method __getitem__ (line 41) | def __getitem__(self, index):
  function str2bool (line 47) | def str2bool(v):
  function main (line 51) | def main(config, train_set, train_loader, val_set, val_loader, test_set,...

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_dcdetector.py
  function to_var (line 23) | def to_var(x, volatile=False):
  function mkdir (line 29) | def mkdir(directory):
  class Logger (line 35) | class Logger(object):
    method __init__ (line 36) | def __init__(self, filename='default.log', add_flag=True, stream=sys.s...
    method write (line 41) | def write(self, message):
    method flush (line 51) | def flush(self):
  function str2bool (line 55) | def str2bool(v):
  function find_nearest (line 59) | def find_nearest(array, value):
  function main (line 65) | def main(config):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_dcdetector_nui.py
  class UniLoader (line 31) | class UniLoader(object):
    method __init__ (line 32) | def __init__(self, data_set, win_size, step, mode="train"):
    method __len__ (line 40) | def __len__(self):
    method __getitem__ (line 48) | def __getitem__(self, index):
  function to_var (line 55) | def to_var(x, volatile=False):
  function mkdir (line 61) | def mkdir(directory):
  class Logger (line 67) | class Logger(object):
    method __init__ (line 68) | def __init__(self, filename='default.log', add_flag=True, stream=sys.s...
    method write (line 73) | def write(self, message):
    method flush (line 83) | def flush(self):
  function str2bool (line 87) | def str2bool(v):
  function find_nearest (line 91) | def find_nearest(array, value):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_donut.py
  function save_checkpoint_callback (line 21) | def save_checkpoint_callback(

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_donut_multi.py
  function save_checkpoint_callback (line 21) | def save_checkpoint_callback(

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_dspot.py
  function adjustment (line 25) | def adjustment(gt, pred):
  function get_range_proba (line 49) | def get_range_proba(predict, label, delay=7):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_dspot_multi.py
  function adjustment (line 30) | def adjustment(gt, pred):
  function get_range_proba (line 54) | def get_range_proba(predict, label, delay=7):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_gpt4ts_uni.py
  class UniLoader (line 20) | class UniLoader(object):
    method __init__ (line 21) | def __init__(self, data_set, win_size, step, mode="train"):
    method __len__ (line 29) | def __len__(self):
    method __getitem__ (line 37) | def __getitem__(self, index):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_lstm_vae.py
  function save_checkpoint_callback (line 21) | def save_checkpoint_callback(

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_lstm_vae_multi.py
  function save_checkpoint_callback (line 21) | def save_checkpoint_callback(

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_spot.py
  function adjustment (line 25) | def adjustment(gt, pred):
  function get_range_proba (line 49) | def get_range_proba(predict, label, delay=7):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_spot_multi.py
  function adjustment (line 25) | def adjustment(gt, pred):
  function get_range_proba (line 49) | def get_range_proba(predict, label, delay=7):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_timesnet_uni.py
  class UniLoader (line 19) | class UniLoader(object):
    method __init__ (line 20) | def __init__(self, data_set, win_size, step, mode="train"):
    method __len__ (line 28) | def __len__(self):
    method __getitem__ (line 36) | def __getitem__(self, index):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_ts2vec.py
  function save_checkpoint_callback (line 21) | def save_checkpoint_callback(

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/train_ts2vec_multi.py
  function save_checkpoint_callback (line 21) | def save_checkpoint_callback(

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/ts2vec.py
  class TS2Vec (line 10) | class TS2Vec:
    method __init__ (line 13) | def __init__(
    method fit (line 60) | def fit(self, train_data, n_epochs=None, n_iters=None, verbose=False):
    method _eval_with_pooling (line 167) | def _eval_with_pooling(self, x, mask=None, slicing=None, encoding_wind...
    method encode (line 211) | def encode(self, data, mask=None, encoding_window=None, casual=False, ...
    method save (line 310) | def save(self, fn):
    method load (line 318) | def load(self, fn):

FILE: ts_anomaly_detection_methods/other_anomaly_baselines/utils.py
  function pkl_save (line 8) | def pkl_save(name, var):
  function pkl_load (line 12) | def pkl_load(name):
  function torch_pad_nan (line 16) | def torch_pad_nan(arr, left=0, right=0, dim=0):
  function pad_nan_to_target (line 30) | def pad_nan_to_target(array, target_length, axis=0, both_side=False):
  function split_with_nan (line 44) | def split_with_nan(x, sections, axis=0):
  function take_per_row (line 52) | def take_per_row(A, indx, num_elem):
  function centerize_vary_length_series (line 56) | def centerize_vary_length_series(x):
  function data_dropout (line 65) | def data_dropout(arr, p):
  function name_with_datetime (line 78) | def name_with_datetime(prefix='default'):
  function init_dl_program (line 82) | def init_dl_program(
  function split_N_pad (line 134) | def split_N_pad(series,window_size):
  function data_slice (line 150) | def data_slice(data,window_size):

FILE: ts_classification_methods/data/dataloader.py
  class UCRDataset (line 6) | class UCRDataset(data.Dataset):
    method __init__ (line 7) | def __init__(self, dataset, target):
    method __getitem__ (line 14) | def __getitem__(self, index):
    method __len__ (line 17) | def __len__(self):
  class UEADataset (line 21) | class UEADataset(data.Dataset):
    method __init__ (line 22) | def __init__(self, dataset, target):
    method __getitem__ (line 26) | def __getitem__(self, index):
    method __len__ (line 29) | def __len__(self):

FILE: ts_classification_methods/data/preprocessing.py
  function load_data (line 10) | def load_data(dataroot, dataset):
  function load_UEA (line 29) | def load_UEA(dataroot, dataset):
  function transfer_labels (line 60) | def transfer_labels(labels):
  function k_fold (line 71) | def k_fold(data, target):
  function normalize_per_series (line 101) | def normalize_per_series(data):
  function normalize_train_val_test (line 107) | def normalize_train_val_test(train_set, val_set, test_set):
  function normalize_uea_set (line 113) | def normalize_uea_set(data_set):
  function fill_nan_value (line 120) | def fill_nan_value(train_set, val_set, test_set):

FILE: ts_classification_methods/gpt4ts/gpt4ts_utils.py
  function build_dataset (line 14) | def build_dataset(args):
  function load_data (line 21) | def load_data(dataroot, dataset):
  function normalize_per_series (line 38) | def normalize_per_series(data):
  function load_UEA (line 45) | def load_UEA(dataroot, dataset):
  function transfer_labels (line 76) | def transfer_labels(labels):
  function k_fold (line 87) | def k_fold(data_set, target):
  function normalize_uea_set (line 117) | def normalize_uea_set(data_set):
  function fill_nan_value (line 124) | def fill_nan_value(train_set, val_set, test_set):
  class UEADataset (line 139) | class UEADataset(data.Dataset):
    method __init__ (line 140) | def __init__(self, dataset, target):
    method __getitem__ (line 144) | def __getitem__(self, index):
    method __len__ (line 147) | def __len__(self):
  function save_cls_new_result (line 151) | def save_cls_new_result(args, mean_accu, max_acc, min_acc, std_acc, trai...
  function set_seed (line 169) | def set_seed(args):
  function get_all_datasets (line 177) | def get_all_datasets(data_set, target):
  function cross_entropy (line 182) | def cross_entropy():
  function reconstruction_loss (line 187) | def reconstruction_loss():
  function build_loss (line 192) | def build_loss(args):

FILE: ts_classification_methods/gpt4ts/main_gpt4ts.py
  function evaluate_gpt4ts (line 22) | def evaluate_gpt4ts(val_loader, model, loss):

FILE: ts_classification_methods/gpt4ts/main_gpt4ts_ucr.py
  function evaluate_gpt4ts (line 22) | def evaluate_gpt4ts(val_loader, model, loss):

FILE: ts_classification_methods/gpt4ts/models/embed.py
  class PositionalEmbedding (line 6) | class PositionalEmbedding(nn.Module):
    method __init__ (line 7) | def __init__(self, d_model, max_len=25000):
    method forward (line 23) | def forward(self, x):
  class TokenEmbedding (line 27) | class TokenEmbedding(nn.Module):
    method __init__ (line 28) | def __init__(self, c_in, d_model):
    method forward (line 38) | def forward(self, x):
  class FixedEmbedding (line 43) | class FixedEmbedding(nn.Module):
    method __init__ (line 44) | def __init__(self, c_in, d_model):
    method forward (line 60) | def forward(self, x):
  class TemporalEmbedding (line 64) | class TemporalEmbedding(nn.Module):
    method __init__ (line 65) | def __init__(self, d_model, embed_type='fixed', freq='h'):
    method forward (line 82) | def forward(self, x):
  class TimeFeatureEmbedding (line 94) | class TimeFeatureEmbedding(nn.Module):
    method __init__ (line 95) | def __init__(self, d_model, embed_type='timeF', freq='h'):
    method forward (line 103) | def forward(self, x):
  class DataEmbedding (line 107) | class DataEmbedding(nn.Module):
    method __init__ (line 108) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 118) | def forward(self, x, x_mark):
  class DataEmbedding_wo_pos (line 127) | class DataEmbedding_wo_pos(nn.Module):
    method __init__ (line 128) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 138) | def forward(self, x, x_mark):
  class PatchEmbedding (line 146) | class PatchEmbedding(nn.Module):
    method __init__ (line 147) | def __init__(self, d_model, patch_len, stride, dropout):
    method forward (line 163) | def forward(self, x):
  class DataEmbedding_wo_time (line 173) | class DataEmbedding_wo_time(nn.Module):
    method __init__ (line 174) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 181) | def forward(self, x):

FILE: ts_classification_methods/gpt4ts/models/gpt4ts.py
  class gpt4ts (line 10) | class gpt4ts(nn.Module):
    method __init__ (line 12) | def __init__(self, max_seq_len, num_classes, var_len, d_model=768, pat...
    method forward (line 52) | def forward(self, x_enc, x_mark_enc=None):

FILE: ts_classification_methods/gpt4ts/models/loss.py
  function get_loss_module (line 6) | def get_loss_module(config):
  function l2_reg_loss (line 23) | def l2_reg_loss(model):
  class NoFussCrossEntropyLoss (line 31) | class NoFussCrossEntropyLoss(nn.CrossEntropyLoss):
    method forward (line 37) | def forward(self, inp, target):
  class MaskedMSELoss (line 42) | class MaskedMSELoss(nn.Module):
    method __init__ (line 46) | def __init__(self, reduction: str = 'mean'):
    method forward (line 53) | def forward(self,

FILE: ts_classification_methods/model/loss.py
  function cross_entropy (line 4) | def cross_entropy():
  function reconstruction_loss (line 9) | def reconstruction_loss():

FILE: ts_classification_methods/model/tsm_model.py
  class Chomp1d (line 7) | class Chomp1d(nn.Module):
    method __init__ (line 8) | def __init__(self, chomp_size):
    method forward (line 12) | def forward(self, x):
  class SqueezeChannels (line 16) | class SqueezeChannels(nn.Module):
    method __init__ (line 17) | def __init__(self):
    method forward (line 20) | def forward(self, x):
  class FCN (line 24) | class FCN(nn.Module):
    method __init__ (line 25) | def __init__(self, num_classes, input_size=1):
    method forward (line 59) | def forward(self, x, vis=False):
  class DilatedBlock (line 69) | class DilatedBlock(nn.Module):
    method __init__ (line 71) | def __init__(self, in_channels, out_channels, kernel_size, dilation, f...
    method forward (line 97) | def forward(self, x):
  class DilatedConvolution (line 109) | class DilatedConvolution(nn.Module):
    method __init__ (line 110) | def __init__(self, in_channels, embedding_channels, out_channels, dept...
    method forward (line 136) | def forward(self, x, vis=False):
  class DilatedConvolutionVis (line 143) | class DilatedConvolutionVis(nn.Module):
    method __init__ (line 144) | def __init__(self, in_channels, embedding_channels, out_channels, dept...
    method forward (line 170) | def forward(self, x, vis=False):
  class Classifier (line 177) | class Classifier(nn.Module):
    method __init__ (line 178) | def __init__(self, input_dims, output_dims) -> None:
    method forward (line 184) | def forward(self, x):
  class NonLinearClassifier (line 188) | class NonLinearClassifier(nn.Module):
    method __init__ (line 189) | def __init__(self, input_dim, embedding_dim, output_dim, dropout=0.2) ...
    method forward (line 201) | def forward(self, x):
  class NonLinearClassifierVis (line 205) | class NonLinearClassifierVis(nn.Module):
    method __init__ (line 206) | def __init__(self, input_dim, embedding_dim, output_dim, dropout=0.2) ...
    method forward (line 224) | def forward(self, x, vis=False):
  class RNNDecoder (line 236) | class RNNDecoder(nn.Module):
    method __init__ (line 237) | def __init__(self, input_dim=1, embedding_dim=128) -> None:
    method forward (line 250) | def forward(self, h1, h2, h3, x):
  function conv_out_len (line 260) | def conv_out_len(seq_len, ker_size, stride, dilation, stack):
  class FCNDecoder (line 269) | class FCNDecoder(nn.Module):
    method __init__ (line 272) | def __init__(self, num_classes, seq_len=None, input_size=None):
    method forward (line 310) | def forward(self, x):

FILE: ts_classification_methods/patchtst/main_patchtst_iota.py
  function create_patch (line 25) | def create_patch(xb, patch_len, stride):
  function evaluate_gpt4ts (line 39) | def evaluate_gpt4ts(args, val_loader, model, loss):

FILE: ts_classification_methods/patchtst/main_patchtst_ucr.py
  function create_patch (line 25) | def create_patch(xb, patch_len, stride):
  function evaluate_gpt4ts (line 39) | def evaluate_gpt4ts(args, val_loader, model, loss):

FILE: ts_classification_methods/patchtst/mian_patchtst.py
  function create_patch (line 25) | def create_patch(xb, patch_len, stride):
  function evaluate_gpt4ts (line 39) | def evaluate_gpt4ts(args, val_loader, model, loss):

FILE: ts_classification_methods/patchtst/models/attention.py
  class MultiheadAttention (line 8) | class MultiheadAttention(nn.Module):
    method __init__ (line 9) | def __init__(self, d_model, n_heads, d_k=None, d_v=None, res_attention...
    method forward (line 35) | def forward(self, Q: Tensor, K: Optional[Tensor] = None, V: Optional[T...
  class ScaledDotProductAttention (line 68) | class ScaledDotProductAttention(nn.Module):
    method __init__ (line 73) | def __init__(self, d_model, n_heads, attn_dropout=0., res_attention=Fa...
    method forward (line 81) | def forward(self, q: Tensor, k: Tensor, v: Tensor, prev: Optional[Tens...

FILE: ts_classification_methods/patchtst/models/basics.py
  class Transpose (line 7) | class Transpose(nn.Module):
    method __init__ (line 8) | def __init__(self, *dims, contiguous=False):
    method forward (line 12) | def forward(self, x):
  class SigmoidRange (line 19) | class SigmoidRange(nn.Module):
    method __init__ (line 20) | def __init__(self, low, high):
    method forward (line 25) | def forward(self, x):
  class LinBnDrop (line 30) | class LinBnDrop(nn.Sequential):
    method __init__ (line 33) | def __init__(self, n_in, n_out, bn=True, p=0., act=None, lin_first=Fal...
  function sigmoid_range (line 42) | def sigmoid_range(x, low, high):
  function get_activation_fn (line 47) | def get_activation_fn(activation):

FILE: ts_classification_methods/patchtst/models/heads.py
  class LinearRegressionHead (line 5) | class LinearRegressionHead(nn.Module):
    method __init__ (line 6) | def __init__(self, n_vars, d_model, output_dim, head_dropout, y_range=...
    method forward (line 13) | def forward(self, x):
  class LinearClassificationHead (line 26) | class LinearClassificationHead(nn.Module):
    method __init__ (line 27) | def __init__(self, n_vars, d_model, n_classes, head_dropout):
    method forward (line 33) | def forward(self, x):
  class LinearPredictionHead (line 45) | class LinearPredictionHead(nn.Module):
    method __init__ (line 46) | def __init__(self, individual, n_vars, d_model, num_patch, forecast_le...
    method forward (line 67) | def forward(self, x):
  class LinearPretrainHead (line 87) | class LinearPretrainHead(nn.Module):
    method __init__ (line 88) | def __init__(self, d_model, patch_len, dropout):
    method forward (line 93) | def forward(self, x):

FILE: ts_classification_methods/patchtst/models/patchTST.py
  class PatchTST (line 9) | class PatchTST(nn.Module):
    method __init__ (line 18) | def __init__(self, c_in: int, target_dim: int, patch_len: int, stride:...
    method forward (line 52) | def forward(self, z):
  class RegressionHead (line 68) | class RegressionHead(nn.Module):
    method __init__ (line 69) | def __init__(self, n_vars, d_model, output_dim, head_dropout, y_range=...
    method forward (line 76) | def forward(self, x):
  class ClassificationHead (line 89) | class ClassificationHead(nn.Module):
    method __init__ (line 90) | def __init__(self, n_vars, d_model, n_classes, head_dropout):
    method forward (line 96) | def forward(self, x):
  class PredictionHead (line 111) | class PredictionHead(nn.Module):
    method __init__ (line 112) | def __init__(self, individual, n_vars, d_model, num_patch, forecast_le...
    method forward (line 133) | def forward(self, x):
  class PretrainHead (line 153) | class PretrainHead(nn.Module):
    method __init__ (line 154) | def __init__(self, d_model, patch_len, dropout):
    method forward (line 159) | def forward(self, x):
  class PatchTSTEncoder (line 171) | class PatchTSTEncoder(nn.Module):
    method __init__ (line 172) | def __init__(self, c_in, num_patch, patch_len,
    method forward (line 203) | def forward(self, x) -> Tensor:
  class TSTEncoder (line 233) | class TSTEncoder(nn.Module):
    method __init__ (line 234) | def __init__(self, d_model, n_heads, d_ff=None,
    method forward (line 246) | def forward(self, src: Tensor):
  class TSTEncoderLayer (line 260) | class TSTEncoderLayer(nn.Module):
    method __init__ (line 261) | def __init__(self, d_model, n_heads, d_ff=256, store_attn=False,
    method forward (line 297) | def forward(self, src: Tensor, prev: Optional[Tensor] = None):

FILE: ts_classification_methods/patchtst/models/pos_encoding.py
  function PositionalEncoding (line 10) | def PositionalEncoding(q_len, d_model, normalize=True):
  function positional_encoding (line 24) | def positional_encoding(pe, learn_pe, q_len, d_model):

FILE: ts_classification_methods/patchtst/models/revin.py
  class RevIN (line 4) | class RevIN(nn.Module):
    method __init__ (line 5) | def __init__(self, num_features: int, eps=1e-5, affine=True):
    method forward (line 18) | def forward(self, x, mode:str):
    method _init_params (line 27) | def _init_params(self):
    method _get_statistics (line 32) | def _get_statistics(self, x):
    method _normalize (line 37) | def _normalize(self, x):
    method _denormalize (line 45) | def _denormalize(self, x):

FILE: ts_classification_methods/patchtst/patch_mask.py
  class GetAttr (line 9) | class GetAttr:
    method _component_attr_filter (line 13) | def _component_attr_filter(self, k):
    method _dir (line 18) | def _dir(self):
    method __getattr__ (line 21) | def __getattr__(self, k):
    method __dir__ (line 27) | def __dir__(self):
    method __setstate__ (line 31) | def __setstate__(self, data):
  function get_device (line 35) | def get_device(use_cuda=True, device_id=None, usage=5):
  function set_device (line 47) | def set_device(usage=5):
  function default_device (line 53) | def default_device(use_cuda=True):
  function get_available_cuda (line 60) | def get_available_cuda(usage=10):
  function to_device (line 69) | def to_device(b, device=None, non_blocking=False):
  function to_numpy (line 86) | def to_numpy(b):
  class Callback (line 99) | class Callback(GetAttr):
  class SetupLearnerCB (line 103) | class SetupLearnerCB(Callback):
    method __init__ (line 104) | def __init__(self):
    method before_batch_train (line 107) | def before_batch_train(self):
    method before_batch_valid (line 110) | def before_batch_valid(self):
    method before_batch_predict (line 113) | def before_batch_predict(self):
    method before_batch_test (line 116) | def before_batch_test(self):
    method _to_device (line 119) | def _to_device(self):
    method before_fit (line 127) | def before_fit(self):
  class GetPredictionsCB (line 133) | class GetPredictionsCB(Callback):
    method __init__ (line 134) | def __init__(self):
    method before_predict (line 137) | def before_predict(self):
    method after_batch_predict (line 140) | def after_batch_predict(self):
    method after_predict (line 144) | def after_predict(self):
  class GetTestCB (line 148) | class GetTestCB(Callback):
    method __init__ (line 149) | def __init__(self):
    method before_test (line 152) | def before_test(self):
    method after_batch_test (line 155) | def after_batch_test(self):
    method after_test (line 160) | def after_test(self):
  class PatchCB (line 166) | class PatchCB(Callback):
    method __init__ (line 168) | def __init__(self, patch_len, stride):
    method before_forward (line 178) | def before_forward(self): self.set_patch()
    method set_patch (line 180) | def set_patch(self):
  class PatchMaskCB (line 189) | class PatchMaskCB(Callback):
    method __init__ (line 190) | def __init__(self, patch_len, stride, mask_ratio,
    method before_fit (line 203) | def before_fit(self):
    method before_forward (line 208) | def before_forward(self): self.patch_masking()
    method patch_masking (line 210) | def patch_masking(self):
    method _loss (line 222) | def _loss(self, preds, target):
  function create_patch (line 233) | def create_patch(xb, patch_len, stride):
  class Patch (line 247) | class Patch(nn.Module):
    method __init__ (line 248) | def __init__(self, seq_len, patch_len, stride):
    method forward (line 257) | def forward(self, x):
  function random_masking (line 266) | def random_masking(xb, mask_ratio):
  function random_masking_3D (line 301) | def random_masking_3D(xb, mask_ratio):

FILE: ts_classification_methods/selftime_cls/dataloader/TSC_data_loader.py
  function set_nan_to_zero (line 6) | def set_nan_to_zero(a):
  function TSC_data_loader (line 12) | def TSC_data_loader(dataset_path,dataset_name):

FILE: ts_classification_methods/selftime_cls/dataloader/ucr2018.py
  class UCR2018 (line 17) | class UCR2018(data.Dataset):
    method __init__ (line 19) | def __init__(self, data, targets, transform):
    method __getitem__ (line 24) | def __getitem__(self, index):
    method __len__ (line 33) | def __len__(self):
  class MultiUCR2018_Intra (line 37) | class MultiUCR2018_Intra(data.Dataset):
    method __init__ (line 39) | def __init__(self, data, targets, K, transform, transform_cut, totenso...
    method __getitem__ (line 47) | def __getitem__(self, index):
    method __len__ (line 65) | def __len__(self):
  class MultiUCR2018_InterIntra (line 69) | class MultiUCR2018_InterIntra(data.Dataset):
    method __init__ (line 71) | def __init__(self, data, targets, K, transform, transform_cut, totenso...
    method __getitem__ (line 79) | def __getitem__(self, index):
    method __len__ (line 99) | def __len__(self):
  class MultiUCR2018 (line 103) | class MultiUCR2018(data.Dataset):
    method __init__ (line 105) | def __init__(self, data, targets, K, transform):
    method __getitem__ (line 111) | def __getitem__(self, index):
    method __len__ (line 124) | def __len__(self):
  function load_ucr2018 (line 128) | def load_ucr2018(dataset_path, dataset_name):

FILE: ts_classification_methods/selftime_cls/dataprepare.py
  function load_data (line 7) | def load_data(dataroot, dataset):
  function transfer_labels (line 29) | def transfer_labels(labels):
  function k_fold (line 39) | def k_fold(data, target):
  function normalize_per_series (line 69) | def normalize_per_series(data):
  function fill_nan_value (line 74) | def fill_nan_value(train_set, val_set, test_set):

FILE: ts_classification_methods/selftime_cls/evaluation/eval_ssl.py
  function evaluation (line 11) | def evaluation(x_train, y_train, x_val, y_val, x_test, y_test, nb_class,...

FILE: ts_classification_methods/selftime_cls/model/model_RelationalReasoning.py
  class RelationalReasoning (line 8) | class RelationalReasoning(torch.nn.Module):
    method __init__ (line 10) | def __init__(self, backbone, feature_size=64):
    method aggregate (line 19) | def aggregate(self, features, K):
    method train (line 50) | def train(self, tot_epochs, train_loader, opt):
  class RelationalReasoning_Intra (line 113) | class RelationalReasoning_Intra(torch.nn.Module):
    method __init__ (line 115) | def __init__(self, backbone, feature_size=64, nb_class=3):
    method run_test (line 127) | def run_test(self, predict, labels):
    method train (line 133) | def train(self, tot_epochs, train_loader, opt):
  class RelationalReasoning_InterIntra (line 204) | class RelationalReasoning_InterIntra(torch.nn.Module):
    method __init__ (line 205) | def __init__(self, backbone, feature_size=64, nb_class=3):
    method aggregate (line 223) | def aggregate(self, features, K):
    method run_test (line 255) | def run_test(self, predict, labels):
    method train (line 261) | def train(self, tot_epochs, train_loader, opt):

FILE: ts_classification_methods/selftime_cls/model/model_backbone.py
  class SimConv4 (line 9) | class SimConv4(torch.nn.Module):
    method __init__ (line 10) | def __init__(self, in_channel=1, feature_size=64):
    method forward (line 60) | def forward(self, x):

FILE: ts_classification_methods/selftime_cls/optim/pretrain.py
  function pretrain_IntraSampleRel (line 10) | def pretrain_IntraSampleRel(x_train, y_train, opt):
  function pretrain_InterSampleRel (line 88) | def pretrain_InterSampleRel(x_train, y_train, opt):
  function pretrain_SelfTime (line 138) | def pretrain_SelfTime(x_train, y_train, opt, in_channel=1):

FILE: ts_classification_methods/selftime_cls/optim/pytorchtools.py
  class EarlyStopping (line 6) | class EarlyStopping:
    method __init__ (line 8) | def __init__(self, patience=50, verbose=False, delta=0, checkpoint_pth...
    method __call__ (line 27) | def __call__(self, val_loss, model):
    method save_checkpoint (line 44) | def save_checkpoint(self, val_loss, model, checkpoint_pth):

FILE: ts_classification_methods/selftime_cls/optim/train.py
  function supervised_train (line 13) | def supervised_train(x_train, y_train, x_val, y_val, x_test, y_test, nb_...

FILE: ts_classification_methods/selftime_cls/train_ssl.py
  function parse_option (line 17) | def parse_option():

FILE: ts_classification_methods/selftime_cls/utils/augmentation.py
  function slidewindow (line 7) | def slidewindow(ts, horizon=.2, stride=0.2):
  function cutout (line 24) | def cutout(ts, perc=.1):
  function cut_piece2C (line 38) | def cut_piece2C(ts, perc=.1):
  function cut_piece3C (line 59) | def cut_piece3C(ts, perc=.1):
  function cut_piece4C (line 83) | def cut_piece4C(ts, perc=.1):
  function cut_piece5C (line 109) | def cut_piece5C(ts, perc=.1):
  function cut_piece6C (line 137) | def cut_piece6C(ts, perc=.1):
  function cut_piece7C (line 167) | def cut_piece7C(ts, perc=.1):
  function cut_piece8C (line 199) | def cut_piece8C(ts, perc=.1):
  function jitter (line 233) | def jitter(x, sigma=0.03):
  function scaling (line 237) | def scaling(x, sigma=0.1):
  function rotation (line 242) | def rotation(x):
  function scaling_s (line 248) | def scaling_s(x, sigma=0.1, plot=False):
  function rotation_s (line 258) | def rotation_s(x, plot=False):
  function rotation2d (line 267) | def rotation2d(x, sigma=0.2):
  function permutation (line 278) | def permutation(x, max_segments=5, seg_mode="equal"):
  function magnitude_warp (line 298) | def magnitude_warp(x, sigma=0.2, knot=4):
  function magnitude_warp_s (line 318) | def magnitude_warp_s(x, sigma=0.2, knot=4, plot=False):
  function time_warp (line 337) | def time_warp(x, sigma=0.2, knot=4):
  function time_warp_s (line 353) | def time_warp_s(x, sigma=0.2, knot=4, plot=False):
  function window_slice (line 372) | def window_slice(x, reduce_ratio=0.9):
  function window_slice_s (line 387) | def window_slice_s(x, reduce_ratio=0.9):
  function window_warp (line 402) | def window_warp(x, window_ratio=0.1, scales=[0.5, 2.]):
  function window_warp_s (line 422) | def window_warp_s(x, window_ratio=0.1, scales=[0.5, 2.]):
  function spawner (line 444) | def spawner(x, labels, sigma=0.05, verbose=0):
  function wdba (line 481) | def wdba(x, labels, batch_size=6, slope_constraint="symmetric", use_wind...
  function random_guided_warp (line 539) | def random_guided_warp(x, labels, slope_constraint="symmetric", use_wind...
  function discriminative_guided_warp (line 573) | def discriminative_guided_warp(x, labels, batch_size=6, slope_constraint...

FILE: ts_classification_methods/selftime_cls/utils/datasets.py
  function nb_dims (line 1) | def nb_dims(dataset):
  function nb_classes (line 6) | def nb_classes(dataset):

FILE: ts_classification_methods/selftime_cls/utils/helper.py
  function plot2d (line 3) | def plot2d(x, y, x2=None, y2=None, x3=None, y3=None, xlim=(-1, 1), ylim=...
  function plot1d (line 21) | def plot1d(x, x2=None, x3=None, ylim=(-1, 1), save_file=""):

FILE: ts_classification_methods/selftime_cls/utils/transforms.py
  class Raw (line 6) | class Raw:
    method __init__ (line 7) | def __init__(self):
    method __call__ (line 10) | def __call__(self, data):
  class CutPiece2C (line 14) | class CutPiece2C:
    method __init__ (line 15) | def __init__(self, sigma):
    method __call__ (line 18) | def __call__(self, data):
    method forward (line 21) | def forward(self, data):
  class CutPiece3C (line 26) | class CutPiece3C:
    method __init__ (line 27) | def __init__(self, sigma):
    method __call__ (line 30) | def __call__(self, data):
    method forward (line 33) | def forward(self, data):
  class CutPiece4C (line 38) | class CutPiece4C:
    method __init__ (line 39) | def __init__(self, sigma):
    method __call__ (line 42) | def __call__(self, data):
    method forward (line 45) | def forward(self, data):
  class CutPiece5C (line 50) | class CutPiece5C:
    method __init__ (line 51) | def __init__(self, sigma):
    method __call__ (line 54) | def __call__(self, data):
    method forward (line 57) | def forward(self, data):
  class CutPiece6C (line 62) | class CutPiece6C:
    method __init__ (line 63) | def __init__(self, sigma):
    method __call__ (line 66) | def __call__(self, data):
    method forward (line 69) | def forward(self, data):
  class CutPiece7C (line 74) | class CutPiece7C:
    method __init__ (line 75) | def __init__(self, sigma):
    method __call__ (line 78) | def __call__(self, data):
    method forward (line 81) | def forward(self, data):
  class CutPiece8C (line 86) | class CutPiece8C:
    method __init__ (line 87) | def __init__(self, sigma):
    method __call__ (line 90) | def __call__(self, data):
    method forward (line 93) | def forward(self, data):
  class Jitter (line 98) | class Jitter:
    method __init__ (line 99) | def __init__(self, sigma, p):
    method __call__ (line 103) | def __call__(self, data):
    method forward (line 110) | def forward(self, data):
  class Scaling (line 115) | class Scaling:
    method __init__ (line 116) | def __init__(self, sigma, p):
    method __call__ (line 120) | def __call__(self, data):
    method forward (line 128) | def forward(self, data):
  class Cutout (line 132) | class Cutout:
    method __init__ (line 133) | def __init__(self, sigma, p):
    method __call__ (line 137) | def __call__(self, data):
    method forward (line 144) | def forward(self, data):
  class MagnitudeWrap (line 148) | class MagnitudeWrap:
    method __init__ (line 149) | def __init__(self, sigma, knot, p):
    method __call__ (line 154) | def __call__(self, data):
    method forward (line 162) | def forward(self, data):
  class TimeWarp (line 166) | class TimeWarp:
    method __init__ (line 167) | def __init__(self, sigma, knot, p):
    method __call__ (line 172) | def __call__(self, data):
    method forward (line 178) | def forward(self, data):
  class WindowSlice (line 182) | class WindowSlice:
    method __init__ (line 183) | def __init__(self, reduce_ratio, p):
    method __call__ (line 187) | def __call__(self, data):
    method forward (line 193) | def forward(self, data):
  class WindowWarp (line 197) | class WindowWarp:
    method __init__ (line 198) | def __init__(self, window_ratio, scales, p):
    method __call__ (line 203) | def __call__(self, data):
    method forward (line 209) | def forward(self, data):
  class ToTensor (line 213) | class ToTensor:
    method __init__ (line 224) | def __init__(self, basic=False):
    method __call__ (line 227) | def __call__(self, img):
    method forward (line 230) | def forward(self, img):
  class Compose (line 245) | class Compose:
    method __init__ (line 246) | def __init__(self, transforms):
    method __call__ (line 249) | def __call__(self, img):
    method forward (line 252) | def forward(self, img):

FILE: ts_classification_methods/selftime_cls/utils/utils.py
  function get_config_from_json (line 5) | def get_config_from_json(json_file):

FILE: ts_classification_methods/selftime_cls/utils/utils_plot.py
  function show_samples (line 7) | def show_samples(X_train, y_train, dataset_name, figname='', num_shown=5):

FILE: ts_classification_methods/timesnet/main_timesnet.py
  function collate_fn (line 23) | def collate_fn(data, device, max_len=None):
  function padding_mask (line 61) | def padding_mask(lengths, max_len=None):
  function evaluate_gpt4ts (line 75) | def evaluate_gpt4ts(args, val_loader, model, loss):

FILE: ts_classification_methods/timesnet/main_timesnet_ucr.py
  function collate_fn (line 23) | def collate_fn(data, device, max_len=None):
  function padding_mask (line 61) | def padding_mask(lengths, max_len=None):
  function evaluate_gpt4ts (line 75) | def evaluate_gpt4ts(args, val_loader, model, loss):

FILE: ts_classification_methods/timesnet/models/Conv_Blocks.py
  class Inception_Block_V1 (line 5) | class Inception_Block_V1(nn.Module):
    method __init__ (line 6) | def __init__(self, in_channels, out_channels, num_kernels=6, init_weig...
    method _initialize_weights (line 18) | def _initialize_weights(self):
    method forward (line 25) | def forward(self, x):
  class Inception_Block_V2 (line 33) | class Inception_Block_V2(nn.Module):
    method __init__ (line 34) | def __init__(self, in_channels, out_channels, num_kernels=6, init_weig...
    method _initialize_weights (line 48) | def _initialize_weights(self):
    method forward (line 55) | def forward(self, x):

FILE: ts_classification_methods/timesnet/models/Embed.py
  class PositionalEmbedding (line 6) | class PositionalEmbedding(nn.Module):
    method __init__ (line 7) | def __init__(self, d_model, max_len=25000):
    method forward (line 23) | def forward(self, x):
  class TokenEmbedding (line 27) | class TokenEmbedding(nn.Module):
    method __init__ (line 28) | def __init__(self, c_in, d_model):
    method forward (line 38) | def forward(self, x):
  class FixedEmbedding (line 43) | class FixedEmbedding(nn.Module):
    method __init__ (line 44) | def __init__(self, c_in, d_model):
    method forward (line 60) | def forward(self, x):
  class TemporalEmbedding (line 64) | class TemporalEmbedding(nn.Module):
    method __init__ (line 65) | def __init__(self, d_model, embed_type='fixed', freq='h'):
    method forward (line 82) | def forward(self, x):
  class TimeFeatureEmbedding (line 94) | class TimeFeatureEmbedding(nn.Module):
    method __init__ (line 95) | def __init__(self, d_model, embed_type='timeF', freq='h'):
    method forward (line 103) | def forward(self, x):
  class DataEmbedding (line 107) | class DataEmbedding(nn.Module):
    method __init__ (line 108) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 118) | def forward(self, x, x_mark):
  class DataEmbedding_inverted (line 127) | class DataEmbedding_inverted(nn.Module):
    method __init__ (line 128) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 133) | def forward(self, x, x_mark):
  class DataEmbedding_wo_pos (line 144) | class DataEmbedding_wo_pos(nn.Module):
    method __init__ (line 145) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 155) | def forward(self, x, x_mark):
  class PatchEmbedding (line 163) | class PatchEmbedding(nn.Module):
    method __init__ (line 164) | def __init__(self, d_model, patch_len, stride, padding, dropout):
    method forward (line 180) | def forward(self, x):

FILE: ts_classification_methods/timesnet/models/SelfAttention_Family.py
  class TriangularCausalMask (line 8) | class TriangularCausalMask():
    method __init__ (line 9) | def __init__(self, B, L, device="cpu"):
    method mask (line 15) | def mask(self):
  class ProbMask (line 19) | class ProbMask():
    method __init__ (line 20) | def __init__(self, B, H, L, index, scores, device="cpu"):
    method mask (line 29) | def mask(self):
  class DSAttention (line 34) | class DSAttention(nn.Module):
    method __init__ (line 37) | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dro...
    method forward (line 44) | def forward(self, queries, keys, values, attn_mask, tau=None, delta=No...
  class FullAttention (line 72) | class FullAttention(nn.Module):
    method __init__ (line 73) | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dro...
    method forward (line 80) | def forward(self, queries, keys, values, attn_mask, tau=None, delta=No...
  class ProbAttention (line 102) | class ProbAttention(nn.Module):
    method __init__ (line 103) | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dro...
    method _prob_QK (line 111) | def _prob_QK(self, Q, K, sample_k, n_top):  # n_top: c*ln(L_q)
    method _get_initial_context (line 137) | def _get_initial_context(self, V, L_Q):
    method _update_context (line 150) | def _update_context(self, context_in, V, scores, index, L_Q, attn_mask):
    method forward (line 171) | def forward(self, queries, keys, values, attn_mask, tau=None, delta=No...
  class AttentionLayer (line 203) | class AttentionLayer(nn.Module):
    method __init__ (line 204) | def __init__(self, attention, d_model, n_heads, d_keys=None,
    method forward (line 218) | def forward(self, queries, keys, values, attn_mask, tau=None, delta=No...
  class TwoStageAttentionLayer (line 270) | class TwoStageAttentionLayer(nn.Module):
    method __init__ (line 276) | def __init__(self, configs,
    method forward (line 302) | def forward(self, x, attn_mask=None, tau=None, delta=None):

FILE: ts_classification_methods/timesnet/models/TimesNet.py
  function FFT_for_Period (line 9) | def FFT_for_Period(x, k=2):
  class TimesBlock (line 23) | class TimesBlock(nn.Module):
    method __init__ (line 24) | def __init__(self, configs):
    method forward (line 38) | def forward(self, x):
  class Model (line 85) | class Model(nn.Module):
    method __init__ (line 90) | def __init__(self, configs):
    method forecast (line 117) | def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
    method imputation (line 144) | def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask):
    method anomaly_detection (line 172) | def anomaly_detection(self, x_enc):
    method classification (line 197) | def classification(self, x_enc, x_mark_enc):
    method forward (line 215) | def forward(self, x_enc, x_mark_enc, x_dec=None, x_mark_dec=None, mask...

FILE: ts_classification_methods/timesnet/models/Transformer.py
  class Model (line 10) | class Model(nn.Module):
    method __init__ (line 17) | def __init__(self, configs):
    method forecast (line 74) | def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
    method imputation (line 83) | def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask):
    method anomaly_detection (line 91) | def anomaly_detection(self, x_enc):
    method classification (line 99) | def classification(self, x_enc, x_mark_enc):
    method forward (line 131) | def forward(self, x_enc, x_mark_enc, x_dec=None, x_mark_dec=None, mask...

FILE: ts_classification_methods/timesnet/models/Transformer_EncDec.py
  class ConvLayer (line 6) | class ConvLayer(nn.Module):
    method __init__ (line 7) | def __init__(self, c_in):
    method forward (line 18) | def forward(self, x):
  class EncoderLayer (line 27) | class EncoderLayer(nn.Module):
    method __init__ (line 28) | def __init__(self, attention, d_model, d_ff=None, dropout=0.1, activat...
    method forward (line 39) | def forward(self, x, attn_mask=None, tau=None, delta=None):
  class Encoder (line 54) | class Encoder(nn.Module):
    method __init__ (line 55) | def __init__(self, attn_layers, conv_layers=None, norm_layer=None):
    method forward (line 61) | def forward(self, x, attn_mask=None, tau=None, delta=None):
  class DecoderLayer (line 83) | class DecoderLayer(nn.Module):
    method __init__ (line 84) | def __init__(self, self_attention, cross_attention, d_model, d_ff=None,
    method forward (line 98) | def forward(self, x, cross, x_mask=None, cross_mask=None, tau=None, de...
  class Decoder (line 119) | class Decoder(nn.Module):
    method __init__ (line 120) | def __init__(self, layers, norm_layer=None, projection=None):
    method forward (line 126) | def forward(self, x, cross, x_mask=None, cross_mask=None, tau=None, de...

FILE: ts_classification_methods/tloss_cls/losses/triplet_loss.py
  class TripletLoss (line 23) | class TripletLoss(torch.nn.modules.loss._Loss):
    method __init__ (line 51) | def __init__(self, compared_length, nb_random_samples, negative_penalty):
    method forward (line 59) | def forward(self, batch, encoder, train, save_memory=False):
  class TripletLossVaryingLength (line 160) | class TripletLossVaryingLength(torch.nn.modules.loss._Loss):
    method __init__ (line 189) | def __init__(self, compared_length, nb_random_samples, negative_penalty):
    method forward (line 197) | def forward(self, batch, encoder, train, save_memory=False):

FILE: ts_classification_methods/tloss_cls/networks/causal_cnn.py
  class Chomp1d (line 49) | class Chomp1d(torch.nn.Module):
    method __init__ (line 60) | def __init__(self, chomp_size):
    method forward (line 64) | def forward(self, x):
  class SqueezeChannels (line 68) | class SqueezeChannels(torch.nn.Module):
    method __init__ (line 72) | def __init__(self):
    method forward (line 75) | def forward(self, x):
  class CausalConvolutionBlock (line 79) | class CausalConvolutionBlock(torch.nn.Module):
    method __init__ (line 94) | def __init__(self, in_channels, out_channels, kernel_size, dilation,
    method forward (line 131) | def forward(self, x):
  class CausalCNN (line 140) | class CausalCNN(torch.nn.Module):
    method __init__ (line 155) | def __init__(self, in_channels, channels, depth, out_channels,
    method forward (line 176) | def forward(self, x):
  class CausalCNNEncoder (line 180) | class CausalCNNEncoder(torch.nn.Module):
    method __init__ (line 199) | def __init__(self, in_channels, channels, depth, reduced_size,
    method forward (line 212) | def forward(self, x):

FILE: ts_classification_methods/tloss_cls/networks/lstm.py
  class LSTMEncoder (line 22) | class LSTMEncoder(torch.nn.Module):
    method __init__ (line 33) | def __init__(self):
    method forward (line 40) | def forward(self, x):

FILE: ts_classification_methods/tloss_cls/scikit_wrappers.py
  class TimeSeriesEncoderClassifier (line 34) | class TimeSeriesEncoderClassifier(sklearn.base.BaseEstimator,
    method __init__ (line 69) | def __init__(self, compared_length, nb_random_samples, negative_penalty,
    method save_encoder (line 94) | def save_encoder(self, prefix_file):
    method save (line 106) | def save(self, prefix_file):
    method load_encoder (line 123) | def load_encoder(self, prefix_file):
    method load (line 141) | def load(self, prefix_file):
    method fit_classifier (line 154) | def fit_classifier(self, features, y):
    method fit_encoder (line 215) | def fit_encoder(self, X, y=None, save_memory=False, verbose=True):
    method fit (line 308) | def fit(self, X, y, save_memory=False, verbose=False):
    method encode (line 332) | def encode(self, X, batch_size=50):
    method encode_window (line 376) | def encode_window(self, X, window, batch_size=50, window_batch_size=10...
    method predict (line 417) | def predict(self, X, batch_size=50):
    method score (line 429) | def score(self, X, y, batch_size=50):
  class CausalCNNEncoderClassifier (line 443) | class CausalCNNEncoderClassifier(TimeSeriesEncoderClassifier):
    method __init__ (line 479) | def __init__(self, compared_length=50, nb_random_samples=10,
    method __create_encoder (line 499) | def __create_encoder(self, in_channels, channels, depth, reduced_size,
    method __encoder_params (line 510) | def __encoder_params(self, in_channels, channels, depth, reduced_size,
    method encode_sequence (line 521) | def encode_sequence(self, X, batch_size=50):
    method get_params (line 615) | def get_params(self, deep=True):
    method set_params (line 635) | def set_params(self, compared_length, nb_random_samples, negative_pena...
  class LSTMEncoderClassifier (line 647) | class LSTMEncoderClassifier(TimeSeriesEncoderClassifier):
    method __init__ (line 676) | def __init__(self, compared_length=50, nb_random_samples=10,
    method __create_encoder (line 688) | def __create_encoder(self, cuda, gpu):
    method get_params (line 695) | def get_params(self, deep=True):
    method set_params (line 710) | def set_params(self, compared_length, nb_random_samples, negative_pena...

FILE: ts_classification_methods/tloss_cls/transfer_ucr.py
  function parse_arguments (line 29) | def parse_arguments():

FILE: ts_classification_methods/tloss_cls/ucr.py
  function load_UCR_dataset (line 36) | def load_UCR_dataset(path, dataset):
  function fit_hyperparameters (line 115) | def fit_hyperparameters(file, train, train_labels, cuda, gpu,
  function parse_arguments (line 146) | def parse_arguments():

FILE: ts_classification_methods/tloss_cls/uea.py
  function fit_hyperparameters (line 38) | def fit_hyperparameters(file, train, train_labels, cuda, gpu,
  function parse_arguments (line 68) | def parse_arguments():

FILE: ts_classification_methods/tloss_cls/utils.py
  class Dataset (line 23) | class Dataset(torch.utils.data.Dataset):
    method __init__ (line 29) | def __init__(self, dataset):
    method __len__ (line 32) | def __len__(self):
    method __getitem__ (line 35) | def __getitem__(self, index):
  class LabelledDataset (line 39) | class LabelledDataset(torch.utils.data.Dataset):
    method __init__ (line 47) | def __init__(self, dataset, labels):
    method __len__ (line 51) | def __len__(self):
    method __getitem__ (line 54) | def __getitem__(self, index):

FILE: ts_classification_methods/ts2vec_cls/datautils.py
  function load_UCR (line 14) | def load_UCR(dataset):
  function load_UEA (line 83) | def load_UEA(dataset):
  function load_forecast_npy (line 112) | def load_forecast_npy(name, univar=False):
  function _get_time_features (line 129) | def _get_time_features(dt):
  function load_forecast_csv (line 141) | def load_forecast_csv(name, univar=False):
  function load_anomaly (line 188) | def load_anomaly(name):
  function gen_ano_train_data (line 195) | def gen_ano_train_data(all_train_data):

FILE: ts_classification_methods/ts2vec_cls/models/dilated_conv.py
  class SamePadConv (line 6) | class SamePadConv(nn.Module):
    method __init__ (line 7) | def __init__(self, in_channels, out_channels, kernel_size, dilation=1,...
    method forward (line 19) | def forward(self, x):
  class ConvBlock (line 25) | class ConvBlock(nn.Module):
    method __init__ (line 26) | def __init__(self, in_channels, out_channels, kernel_size, dilation, f...
    method forward (line 32) | def forward(self, x):
  class DilatedConvEncoder (line 40) | class DilatedConvEncoder(nn.Module):
    method __init__ (line 41) | def __init__(self, in_channels, channels, kernel_size):
    method forward (line 54) | def forward(self, x):

FILE: ts_classification_methods/ts2vec_cls/models/encoder.py
  function generate_continuous_mask (line 7) | def generate_continuous_mask(B, T, n=5, l=0.1):
  function generate_binomial_mask (line 23) | def generate_binomial_mask(B, T, p=0.5):
  class TSEncoder (line 26) | class TSEncoder(nn.Module):
    method __init__ (line 27) | def __init__(self, input_dims, output_dims, hidden_dims=64, depth=10, ...
    method forward (line 41) | def forward(self, x, mask=None):  # x: B x T x input_dims

FILE: ts_classification_methods/ts2vec_cls/models/losses.py
  function hierarchical_contrastive_loss (line 5) | def hierarchical_contrastive_loss(z1, z2, alpha=0.5, temporal_unit=0):
  function instance_contrastive_loss (line 23) | def instance_contrastive_loss(z1, z2):
  function temporal_contrastive_loss (line 38) | def temporal_contrastive_loss(z1, z2):

FILE: ts_classification_methods/ts2vec_cls/tasks/_eval_protocols.py
  function fit_svm (line 10) | def fit_svm(features, y, MAX_SAMPLES=10000):
  function fit_lr (line 52) | def fit_lr(features, y, MAX_SAMPLES=100000):
  function fit_knn (line 73) | def fit_knn(features, y):
  function fit_ridge (line 81) | def fit_ridge(train_features, train_y, valid_features, valid_y, MAX_SAMP...

FILE: ts_classification_methods/ts2vec_cls/tasks/classification.py
  function eval_classification (line 6) | def eval_classification(model, train_data, train_labels, test_data, test...

FILE: ts_classification_methods/ts2vec_cls/train.py
  function save_checkpoint_callback (line 12) | def save_checkpoint_callback(

FILE: ts_classification_methods/ts2vec_cls/train_fcn.py
  function save_checkpoint_callback (line 22) | def save_checkpoint_callback(

FILE: ts_classification_methods/ts2vec_cls/train_tsm.py
  function save_checkpoint_callback (line 21) | def save_checkpoint_callback(

FILE: ts_classification_methods/ts2vec_cls/train_tsm_uea.py
  function save_checkpoint_callback (line 22) | def save_checkpoint_callback(

FILE: ts_classification_methods/ts2vec_cls/ts2vec.py
  class TS2Vec (line 10) | class TS2Vec:
    method __init__ (line 13) | def __init__(
    method fit (line 60) | def fit(self, train_data, n_epochs=None, n_iters=None, verbose=False):
    method _eval_with_pooling (line 164) | def _eval_with_pooling(self, x, mask=None, slicing=None, encoding_wind...
    method encode (line 208) | def encode(self, data, mask=None, encoding_window=None, casual=False, ...
    method save (line 305) | def save(self, fn):
    method load (line 313) | def load(self, fn):

FILE: ts_classification_methods/ts2vec_cls/utils.py
  function pkl_save (line 8) | def pkl_save(name, var):
  function pkl_load (line 12) | def pkl_load(name):
  function torch_pad_nan (line 16) | def torch_pad_nan(arr, left=0, right=0, dim=0):
  function pad_nan_to_target (line 27) | def pad_nan_to_target(array, target_length, axis=0, both_side=False):
  function split_with_nan (line 39) | def split_with_nan(x, sections, axis=0):
  function take_per_row (line 47) | def take_per_row(A, indx, num_elem):
  function centerize_vary_length_series (line 51) | def centerize_vary_length_series(x):
  function data_dropout (line 60) | def data_dropout(arr, p):
  function name_with_datetime (line 73) | def name_with_datetime(prefix='default'):
  function init_dl_program (line 77) | def init_dl_program(

FILE: ts_classification_methods/tsm_utils.py
  function set_seed (line 14) | def set_seed(args):
  function build_model (line 22) | def build_model(args):
  function build_dataset (line 44) | def build_dataset(args):
  function build_loss (line 51) | def build_loss(args):
  function build_optimizer (line 58) | def build_optimizer(args):
  function evaluate (line 65) | def evaluate(val_loader, model, classifier, loss, device):
  function save_finetune_result (line 86) | def save_finetune_result(args, accu, std):
  function save_cls_result (line 102) | def save_cls_result(args, test_accu, test_std, train_time, end_val_epoch...
  function get_all_datasets (line 120) | def get_all_datasets(data, target):

FILE: ts_classification_methods/tst_cls/src/dataprepare.py
  function load_data (line 16) | def load_data(dataroot, dataset):
  function transfer_labels (line 38) | def transfer_labels(labels):
  function k_fold (line 49) | def k_fold(data, target):
  function normalize_per_series (line 80) | def normalize_per_series(data):
  function fill_nan_value (line 86) | def fill_nan_value(train_set, val_set, test_set):
  function fill_nan_and_normalize (line 105) | def fill_nan_and_normalize(train_data, val_data, test_data, train_indice...

FILE: ts_classification_methods/tst_cls/src/datasets/data.py
  class Normalizer (line 19) | class Normalizer(object):
    method __init__ (line 24) | def __init__(self, norm_type, mean=None, std=None, min_val=None, max_v...
    method normalize (line 39) | def normalize(self, df):
  function interpolate_missing (line 72) | def interpolate_missing(y):
  function subsample (line 81) | def subsample(y, limit=256, factor=2):
  class BaseData (line 90) | class BaseData(object):
    method set_num_processes (line 92) | def set_num_processes(self, n_proc):
  class HDD_data (line 100) | class HDD_data(BaseData):
    method __init__ (line 109) | def __init__(self, root_dir, file_list=None, pattern=None, n_proc=1, l...
    method load_all (line 125) | def load_all(self, dir_path):
    method load_single (line 152) | def load_single(filepath):
    method read_data (line 159) | def read_data(filepath):
    method select_columns (line 167) | def select_columns(df):
    method process_columns (line 176) | def process_columns(df):
  class WeldData (line 186) | class WeldData(BaseData):
    method __init__ (line 199) | def __init__(self, root_dir, file_list=None, pattern=None, n_proc=1, l...
    method load_all (line 225) | def load_all(self, root_dir, file_list=None, pattern=None):
    method load_single (line 276) | def load_single(filepath):
    method read_data (line 288) | def read_data(filepath):
    method select_columns (line 295) | def select_columns(df):
  class TSRegressionArchive (line 311) | class TSRegressionArchive(BaseData):
    method __init__ (line 327) | def __init__(self, root_dir, file_list=None, pattern=None, n_proc=1, l...
    method load_all (line 350) | def load_all(self, root_dir, file_list=None, pattern=None):
    method load_single (line 408) | def load_single(self, filepath):
  class SemicondTraceData (line 475) | class SemicondTraceData(BaseData):
    method __init__ (line 553) | def __init__(self, root_dir, file_list=None, pattern=None, n_proc=8, l...
    method make_pjid (line 612) | def make_pjid(self, toolID, pjID):
    method convert_tracefilename (line 616) | def convert_tracefilename(self, filepath):
    method get_measurements (line 625) | def get_measurements(self, wafer_measurements_path):
    method get_metadata (line 685) | def get_metadata(self, catalog_path, measurements_df):
    method load_all (line 706) | def load_all(self, root_dir, file_list=None, pattern=None, mode=None):
    method load_single (line 767) | def load_single(filepath):
    method read_data (line 786) | def read_data(filepath):
    method select_columns (line 793) | def select_columns(df):
  class PMUData (line 810) | class PMUData(BaseData):
    method __init__ (line 823) | def __init__(self, root_dir, file_list=None, pattern=None, n_proc=1, l...
    method load_all (line 860) | def load_all(self, root_dir, file_list=None, pattern=None):
    method load_single (line 910) | def load_single(filepath):
    method read_data (line 922) | def read_data(filepath):

FILE: ts_classification_methods/tst_cls/src/datasets/dataset.py
  class ImputationDataset (line 6) | class ImputationDataset(Dataset):
    method __init__ (line 9) | def __init__(self, data, indices, mean_mask_length=3, masking_ratio=0.15,
    method __getitem__ (line 27) | def __getitem__(self, ind):
    method update (line 45) | def update(self):
    method __len__ (line 49) | def __len__(self):
  class TransductionDataset (line 53) | class TransductionDataset(Dataset):
    method __init__ (line 55) | def __init__(self, data, indices, mask_feats, start_hint=0.0, end_hint...
    method __getitem__ (line 69) | def __getitem__(self, ind):
    method update (line 87) | def update(self):
    method __len__ (line 91) | def __len__(self):
  function collate_superv (line 95) | def collate_superv(data, max_len=None, device=None):
  class ClassiregressionDataset (line 134) | class ClassiregressionDataset(Dataset):
    method __init__ (line 136) | def __init__(self, data, indices, device=None, feature_df=None):
    method __getitem__ (line 154) | def __getitem__(self, ind):
    method __len__ (line 173) | def __len__(self):
  function transduct_mask (line 177) | def transduct_mask(X, mask_feats, start_hint=0.0, end_hint=0.0):
  function compensate_masking (line 198) | def compensate_masking(X, mask):
  function collate_unsuperv (line 218) | def collate_unsuperv(data, max_len=None, mask_compensation=False):
  function noise_mask (line 263) | def noise_mask(X, masking_ratio, lm=3, mode='separate', distribution='ge...
  function geom_noise_mask_single (line 306) | def geom_noise_mask_single(L, lm, masking_ratio):
  function padding_mask (line 337) | def padding_mask(lengths, max_len=None):

FILE: ts_classification_methods/tst_cls/src/datasets/datasplit.py
  function split_dataset (line 5) | def split_dataset(data_indices, validation_method, n_splits, validation_...
  class DataSplitter (line 50) | class DataSplitter(object):
    method __init__ (line 53) | def __init__(self, data_indices, data_labels=None, ith=None):
    method factory (line 68) | def factory(split_type, *args, **kwargs):
    method split_testset (line 79) | def split_testset(self, test_ratio, random_state=1337):
    method split_validation (line 91) | def split_validation(self):
  class StratifiedKFoldSplitter (line 114) | class StratifiedKFoldSplitter(DataSplitter):
    method split_testset (line 115) | def split_testset(self, test_ratio, random_state=42):
    method split_validation (line 139) | def split_validation(self, n_splits, validation_ratio, random_state=42):
  class StratifiedShuffleSplitter (line 161) | class StratifiedShuffleSplitter(DataSplitter):
    method split_testset (line 168) | def split_testset(self, test_ratio, random_state=1337):
    method split_validation (line 191) | def split_validation(self, n_splits, validation_ratio, random_state=13...
  class ShuffleSplitter (line 218) | class ShuffleSplitter(DataSplitter):
    method split_testset (line 225) | def split_testset(self, test_ratio, random_state=1337):
    method split_validation (line 249) | def split_validation(self, n_splits, validation_ratio, random_state=13...

FILE: ts_classification_methods/tst_cls/src/datasets/utils.py
  function uniform_scaling (line 32) | def uniform_scaling(data, max_len):
  class TsFileParseException (line 46) | class TsFileParseException(Exception):
  function load_from_tsfile_to_dataframe (line 53) | def load_from_tsfile_to_dataframe(full_file_path_and_name, return_separa...
  function process_data (line 562) | def process_data(X, min_len, normalise=None):

FILE: ts_classification_methods/tst_cls/src/main.py
  function main (line 43) | def main(config):

FILE: ts_classification_methods/tst_cls/src/models/loss.py
  function get_loss_module (line 6) | def get_loss_module(config):
  function l2_reg_loss (line 23) | def l2_reg_loss(model):
  class NoFussCrossEntropyLoss (line 31) | class NoFussCrossEntropyLoss(nn.CrossEntropyLoss):
    method forward (line 37) | def forward(self, inp, target):
  class MaskedMSELoss (line 42) | class MaskedMSELoss(nn.Module):
    method __init__ (line 46) | def __init__(self, reduction: str = 'mean'):
    method forward (line 53) | def forward(self,

FILE: ts_classification_methods/tst_cls/src/models/ts_transformer.py
  function model_factory (line 10) | def model_factory(config, data, labels=None):
  function _get_activation_fn (line 77) | def _get_activation_fn(activation):
  class FixedPositionalEncoding (line 87) | class FixedPositionalEncoding(nn.Module):
    method __init__ (line 102) | def __init__(self, d_model, dropout=0.1, max_len=1024, scale_factor=1.0):
    method forward (line 116) | def forward(self, x):
  class LearnablePositionalEncoding (line 129) | class LearnablePositionalEncoding(nn.Module):
    method __init__ (line 131) | def __init__(self, d_model, dropout=0.1, max_len=1024):
    method forward (line 140) | def forward(self, x):
  function get_pos_encoder (line 153) | def get_pos_encoder(pos_encoding):
  class TransformerBatchNormEncoderLayer (line 163) | class TransformerBatchNormEncoderLayer(nn.modules.Module):
    method __init__ (line 176) | def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, ...
    method __setstate__ (line 192) | def __setstate__(self, state):
    method forward (line 197) | def forward(self, src: Tensor, src_mask: Optional[Tensor] = None,
  class TSTransformerEncoder (line 224) | class TSTransformerEncoder(nn.Module):
    method __init__ (line 226) | def __init__(self, feat_dim, max_len, d_model, n_heads, num_layers, di...
    method forward (line 256) | def forward(self, X, padding_masks):
  class TSTransformerEncoderClassiregressor (line 285) | class TSTransformerEncoderClassiregressor(nn.Module):
    method __init__ (line 291) | def __init__(self, feat_dim, max_len, d_model, n_heads, num_layers, di...
    method build_output_module (line 322) | def build_output_module(self, d_model, max_len, num_classes, nonlinear...
    method forward (line 340) | def forward(self, X, padding_masks):

FILE: ts_classification_methods/tst_cls/src/optimizers.py
  function get_optimizer (line 6) | def get_optimizer(name):
  class RAdam (line 15) | class RAdam(Optimizer):
    method __init__ (line 17) | def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weig...
    method __setstate__ (line 36) | def __setstate__(self, state):
    method step (line 39) | def step(self, closure=None):
  class PlainRAdam (line 110) | class PlainRAdam(Optimizer):
    method __init__ (line 112) | def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weig...
    method __setstate__ (line 127) | def __setstate__(self, state):
    method step (line 130) | def step(self, closure=None):
  class AdamW (line 188) | class AdamW(Optimizer):
    method __init__ (line 190) | def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, weig...
    method __setstate__ (line 204) | def __setstate__(self, state):
    method step (line 207) | def step(self, closure=None):

FILE: ts_classification_methods/tst_cls/src/options.py
  class Options (line 4) | class Options(object):
    method __init__ (line 6) | def __init__(self):
    method parse (line 179) | def parse(self):

FILE: ts_classification_methods/tst_cls/src/running.py
  function pipeline_factory (line 32) | def pipeline_factory(config, device):
  function setup (line 56) | def setup(args):
  function fold_evaluate (line 104) | def fold_evaluate(dataset, model, device, loss_module, target_feats, con...
  function convert_metrics_per_batch_to_per_sample (line 149) | def convert_metrics_per_batch_to_per_sample(metrics, target_masks):
  function evaluate (line 171) | def evaluate(evaluator):
  function validate (line 189) | def validate(val_evaluator, tensorboard_writer, config, best_metrics, be...
  function check_progress (line 213) | def check_progress(epoch):
  class BaseRunner (line 221) | class BaseRunner(object):
    method __init__ (line 223) | def __init__(self, model, dataloader, device, loss_module, optimizer=N...
    method train_epoch (line 236) | def train_epoch(self, epoch_num=None):
    method evaluate (line 239) | def evaluate(self, epoch_num=None, keep_all=True):
    method print_callback (line 242) | def print_callback(self, i_batch, metrics, prefix=''):
  class UnsupervisedRunner (line 257) | class UnsupervisedRunner(BaseRunner):
    method train_epoch (line 259) | def train_epoch(self, epoch_num=None):
    method evaluate (line 306) | def evaluate(self, epoch_num=None, keep_all=False):
  class SupervisedRunner (line 363) | class SupervisedRunner(BaseRunner):
    method __init__ (line 365) | def __init__(self, *args, **kwargs):
    method train_epoch (line 375) | def train_epoch(self, epoch_num=None):
    method evaluate (line 429) | def evaluate(self, epoch_num=None, keep_all=True):

FILE: ts_classification_methods/tst_cls/src/utils/analysis.py
  function acc_top_k (line 18) | def acc_top_k(predictions, y_true):
  function accuracy (line 44) | def accuracy(y_pred, y_true, excluded_labels=None):
  function precision (line 60) | def precision(y_true, y_pred, label):
  function recall (line 70) | def recall(y_true, y_pred, label):
  function limiter (line 80) | def limiter(metric_functions, y_true, y_pred, y_scores, score_thr, label):
  function prec_rec_parametrized_by_thr (line 93) | def prec_rec_parametrized_by_thr(y_true, y_pred, y_scores, label, Npoint...
  function plot_prec_vs_rec (line 121) | def plot_prec_vs_rec(score_grid, rec, prec, prec_requirement=None, thr_o...
  function plot_confusion_matrix (line 177) | def plot_confusion_matrix(ConfMat, label_strings=None, title='Confusion ...
  function print_confusion_matrix (line 191) | def print_confusion_matrix(ConfMat, label_strings=None, title='Confusion...
  class Analyzer (line 206) | class Analyzer(object):
    method __init__ (line 208) | def __init__(self, maxcharlength=35, plot=False, print_conf_mat=False,...
    method show_acc_top_k_improvement (line 234) | def show_acc_top_k_improvement(self, y_pred, y_true, k=5, inp='scores'):
    method generate_classification_report (line 274) | def generate_classification_report(self, digits=3, number_of_thieves=2...
    method get_avg_prec_recall (line 340) | def get_avg_prec_recall(self, ConfMatrix, existing_class_names, exclud...
    method prec_rec_histogram (line 366) | def prec_rec_histogram(self, precision, recall, binedges=None):
    method analyze_classification (line 409) | def analyze_classification(self, y_pred, y_true, class_names, excluded...

FILE: ts_classification_methods/tst_cls/src/utils/utils.py
  function timer (line 21) | def timer(func):
  function save_model (line 34) | def save_model(path, epoch, model, optimizer=None):
  function load_model (line 46) | def load_model(model, model_path, optimizer=None, resume=False, change_o...
  function load_config (line 78) | def load_config(config_filepath):
  function create_dirs (line 90) | def create_dirs(dirs):
  function export_performance_metrics (line 107) | def export_performance_metrics(filepath, metrics_table, header, book=Non...
  function write_row (line 121) | def write_row(sheet, row_ind, data_list):
  function write_table_to_sheet (line 130) | def write_table_to_sheet(table, work_book, sheet_name=None):
  function export_record (line 141) | def export_record(filepath, values):
  function register_record (line 154) | def register_record(filepath, timestamp, experiment_name, best_metrics, ...
  class Printer (line 195) | class Printer(object):
    method __init__ (line 198) | def __init__(self, console=True):
    method dyn_print (line 206) | def dyn_print(data):
  function readable_time (line 212) | def readable_time(time_difference):
  function check_model (line 243) | def check_model(model, verbose=False, zero_thresh=1e-8, inf_thresh=1e6, ...
  function check_tensor (line 265) | def check_tensor(X, verbose=True, zero_thresh=1e-8, inf_thresh=1e6):
  function count_parameters (line 298) | def count_parameters(model, trainable=False):
  function recursively_hook (line 305) | def recursively_hook(model, hook_fn):
  function compute_loss (line 314) | def compute_loss(net: torch.nn.Module,

FILE: ts_classification_methods/tstcc_cls/config_files/ucr_Configs.py
  class Config (line 1) | class Config(object):
    method __init__ (line 2) | def __init__(self):
  class augmentations (line 30) | class augmentations(object):
    method __init__ (line 31) | def __init__(self):
  class Context_Cont_configs (line 37) | class Context_Cont_configs(object):
    method __init__ (line 38) | def __init__(self):
  class TC (line 43) | class TC(object):
    method __init__ (line 44) | def __init__(self):

FILE: ts_classification_methods/tstcc_cls/config_files/uea_Configs.py
  class Config (line 1) | class Config(object):
    method __init__ (line 2) | def __init__(self):
  class augmentations (line 30) | class augmentations(object):
    method __init__ (line 31) | def __init__(self):
  class Context_Cont_configs (line 37) | class Context_Cont_configs(object):
    method __init__ (line 38) | def __init__(self):
  class TC (line 43) | class TC(object):
    method __init__ (line 44) | def __init__(self):

FILE: ts_classification_methods/tstcc_cls/dataloader/augmentations.py
  function DataTransform (line 5) | def DataTransform(sample, config):
  function jitter (line 13) | def jitter(x, sigma=0.8):
  function scaling (line 18) | def scaling(x, sigma=1.1):
  function permutation (line 28) | def permutation(x, max_segments=5, seg_mode="random"):

FILE: ts_classification_methods/tstcc_cls/dataloader/dataloader.py
  class Load_Dataset (line 11) | class Load_Dataset(Dataset):
    method __init__ (line 13) | def __init__(self, dataset, config, training_mode):
    method __getitem__ (line 41) | def __getitem__(self, index):
    method __len__ (line 47) | def __len__(self):
  function data_generator (line 51) | def data_generator(data_path, configs, training_mode):

FILE: ts_classification_methods/tstcc_cls/models/TC.py
  class TC (line 8) | class TC(nn.Module):
    method __init__ (line 9) | def __init__(self, configs, device):
    method forward (line 26) | def forward(self, features_aug1, features_aug2):

FILE: ts_classification_methods/tstcc_cls/models/attention.py
  class Residual (line 9) | class Residual(nn.Module):
    method __init__ (line 10) | def __init__(self, fn):
    method forward (line 14) | def forward(self, x, **kwargs):
  class PreNorm (line 18) | class PreNorm(nn.Module):
    method __init__ (line 19) | def __init__(self, dim, fn):
    method forward (line 24) | def forward(self, x, **kwargs):
  class FeedForward (line 28) | class FeedForward(nn.Module):
    method __init__ (line 29) | def __init__(self, dim, hidden_dim, dropout=0.):
    method forward (line 39) | def forward(self, x):
  class Attention (line 43) | class Attention(nn.Module):
    method __init__ (line 44) | def __init__(self, dim, heads=8, dropout=0.):
    method forward (line 55) | def forward(self, x, mask=None):
  class Transformer (line 77) | class Transformer(nn.Module):
    method __init__ (line 78) | def __init__(self, dim, depth, heads, mlp_dim, dropout):
    method forward (line 87) | def forward(self, x, mask=None):
  class Seq_Transformer (line 94) | class Seq_Transformer(nn.Module):
    method __init__ (line 95) | def __init__(self, *, patch_size, dim, depth, heads, mlp_dim, channels...
    method forward (line 104) | def forward(self, forward_seq):

FILE: ts_classification_methods/tstcc_cls/models/loss.py
  class NTXentLoss (line 4) | class NTXentLoss(torch.nn.Module):
    method __init__ (line 6) | def __init__(self, device, batch_size, temperature, use_cosine_similar...
    method _get_similarity_function (line 16) | def _get_similarity_function(self, use_cosine_similarity):
    method _get_correlated_mask (line 23) | def _get_correlated_mask(self):
    method _dot_simililarity (line 32) | def _dot_simililarity(x, y):
    method _cosine_simililarity (line 39) | def _cosine_simililarity(self, x, y):
    method forward (line 46) | def forward(self, zis, zjs):

FILE: ts_classification_methods/tstcc_cls/models/model.py
  class base_Model (line 3) | class base_Model(nn.Module):
    method __init__ (line 4) | def __init__(self, configs):
    method forward (line 33) | def forward(self, x_in):

FILE: ts_classification_methods/tstcc_cls/trainer/trainer.py
  function Trainer (line 14) | def Trainer(model, temporal_contr_model, model_optimizer, temp_cont_opti...
  function Trainer_cls (line 46) | def Trainer_cls(model, temporal_contr_model, model_optimizer, temp_cont_...
  function model_train (line 89) | def model_train(model, temporal_contr_model, model_optimizer, temp_cont_...
  function model_evaluate (line 149) | def model_evaluate(model, temporal_contr_model, test_dl, device, trainin...

FILE: ts_classification_methods/tstcc_cls/utils.py
  function generator_ucr_config (line 15) | def generator_ucr_config(data, label, configs):
  function generator_ucr (line 35) | def generator_ucr(data, label, configs, training_mode, drop_last=True):
  function generator_uea_config (line 53) | def generator_uea_config(data, label, configs):
  function generator_uea (line 72) | def generator_uea(data, label, configs, training_mode, drop_last=True):
  function set_requires_grad (line 87) | def set_requires_grad(model, dict_, requires_grad=True):
  function fix_randomness (line 93) | def fix_randomness(SEED):
  function epoch_time (line 101) | def epoch_time(start_time, end_time):
  function _calc_metrics (line 108) | def _calc_metrics(pred_labels, true_labels, log_dir, home_path):
  function _logger (line 138) | def _logger(logger_name, level=logging.DEBUG):
  function copy_Files (line 159) | def copy_Files(destination, data_type):

FILE: ts_classification_methods/visualize.py
  function heatmap (line 18) | def heatmap(xs, ys, dataset_name='MixedShapesSmallTrain', num_class=5, c...
  function multi_cam (line 83) | def multi_cam(xs, ys):

FILE: ts_forecasting_methods/CoST/cost.py
  class PretrainDataset (line 17) | class PretrainDataset(Dataset):
    method __init__ (line 19) | def __init__(self,
    method __getitem__ (line 31) | def __getitem__(self, item):
    method __len__ (line 35) | def __len__(self):
    method transform (line 38) | def transform(self, x):
    method jitter (line 41) | def jitter(self, x):
    method scale (line 46) | def scale(self, x):
    method shift (line 51) | def shift(self, x):
  class CoSTModel (line 57) | class CoSTModel(nn.Module):
    method __init__ (line 58) | def __init__(self,
    method compute_loss (line 104) | def compute_loss(self, q, k, k_negs):
    method convert_coeff (line 123) | def convert_coeff(self, x, eps=1e-6):
    method instance_contrastive_loss (line 128) | def instance_contrastive_loss(self, z1, z2):
    method forward (line 141) | def forward(self, x_q, x_k):
    method _momentum_update_key_encoder (line 177) | def _momentum_update_key_encoder(self):
    method _dequeue_and_enqueue (line 187) | def _dequeue_and_enqueue(self, keys):
  class CoST (line 200) | class CoST:
    method __init__ (line 201) | def __init__(self,
    method fit (line 250) | def fit(self, train_data, n_epochs=None, n_iters=None, verbose=False):
    method _eval_with_pooling (line 334) | def _eval_with_pooling(self, x, mask=None, slicing=None, encoding_wind...
    method encode (line 339) | def encode(self, data, mode, mask=None, encoding_window=None, casual=F...
    method save (line 427) | def save(self, fn):
    method load (line 435) | def load(self, fn):
  function adjust_learning_rate (line 445) | def adjust_learning_rate(optimizer, lr, epoch, epochs):

FILE: ts_forecasting_methods/CoST/datautils.py
  function load_forecast_npy (line 6) | def load_forecast_npy(name, univar=False):
  function _get_time_features (line 22) | def _get_time_features(dt):
  function load_forecast_csv (line 33) | def load_forecast_csv(name, univar=False):

FILE: ts_forecasting_methods/CoST/models/dilated_conv.py
  class SamePadConv (line 6) | class SamePadConv(nn.Module):
    method __init__ (line 7) | def __init__(self, in_channels, out_channels, kernel_size, dilation=1,...
    method forward (line 19) | def forward(self, x):
  class ConvBlock (line 26) | class ConvBlock(nn.Module):
    method __init__ (line 27) | def __init__(self, in_channels, out_channels, kernel_size, dilation, f...
    method forward (line 33) | def forward(self, x):
  class DilatedConvEncoder (line 42) | class DilatedConvEncoder(nn.Module):
    method __init__ (line 43) | def __init__(self, in_channels, channels, kernel_size, extract_layers=...
    method forward (line 61) | def forward(self, x):

FILE: ts_forecasting_methods/CoST/models/encoder.py
  function generate_continuous_mask (line 15) | def generate_continuous_mask(B, T, n=5, l=0.1):
  function generate_binomial_mask (line 32) | def generate_binomial_mask(B, T, p=0.5):
  class BandedFourierLayer (line 36) | class BandedFourierLayer(nn.Module):
    method __init__ (line 37) | def __init__(self, in_channels, out_channels, band, num_bands, length=...
    method forward (line 60) | def forward(self, input):
    method _forward (line 68) | def _forward(self, input):
    method reset_parameters (line 72) | def reset_parameters(self) -> None:
  class CoSTEncoder (line 79) | class CoSTEncoder(nn.Module):
    method __init__ (line 80) | def __init__(self, input_dims, output_dims,
    method forward (line 114) | def forward(self, x, tcn_output=False, mask='all_true'):  # x: B x T x...

FILE: ts_forecasting_methods/CoST/tasks/_eval_protocols.py
  function fit_ridge (line 6) | def fit_ridge(train_features, train_y, valid_features, valid_y, MAX_SAMP...

FILE: ts_forecasting_methods/CoST/tasks/forecasting.py
  function generate_pred_samples (line 6) | def generate_pred_samples(features, data, pred_len, drop=0):
  function cal_metrics (line 16) | def cal_metrics(pred, target):
  function eval_forecasting (line 23) | def eval_forecasting(model, data, train_slice, valid_slice, test_slice, ...

FILE: ts_forecasting_methods/CoST/train.py
  function save_checkpoint_callback (line 15) | def save_checkpoint_callback(

FILE: ts_forecasting_methods/CoST/utils.py
  function pkl_save (line 10) | def pkl_save(name, var):
  function pkl_load (line 14) | def pkl_load(name):
  function torch_pad_nan (line 18) | def torch_pad_nan(arr, left=0, right=0, dim=0):
  function pad_nan_to_target (line 29) | def pad_nan_to_target(array, target_length, axis=0, both_side=False):
  function split_with_nan (line 41) | def split_with_nan(x, sections, axis=0):
  function take_per_row (line 49) | def take_per_row(A, indx, num_elem):
  function centerize_vary_length_series (line 53) | def centerize_vary_length_series(x):
  function data_dropout (line 62) | def data_dropout(arr, p):
  function name_with_datetime (line 75) | def name_with_datetime(prefix='default'):
  function init_dl_program (line 79) | def init_dl_program(

FILE: ts_forecasting_methods/Other_baselines/data_provider/data_factory.py
  function data_provider (line 22) | def data_provider(args, flag):

FILE: ts_forecasting_methods/Other_baselines/data_provider/data_factory_tempo.py
  function data_provider (line 12) | def data_provider(args, flag, drop_last_test=True, train_all=False):

FILE: ts_forecasting_methods/Other_baselines/data_provider/data_loader.py
  class Dataset_ETT_hour (line 19) | class Dataset_ETT_hour(Dataset):
    method __init__ (line 20) | def __init__(self, args, root_path, flag='train', size=None,
    method __read_data__ (line 49) | def __read_data__(self):
    method __getitem__ (line 97) | def __getitem__(self, index):
    method __len__ (line 110) | def __len__(self):
    method inverse_transform (line 113) | def inverse_transform(self, data):
  class Dataset_ETT_minute (line 117) | class Dataset_ETT_minute(Dataset):
    method __init__ (line 118) | def __init__(self, args, root_path, flag='train', size=None,
    method __read_data__ (line 147) | def __read_data__(self):
    method __getitem__ (line 193) | def __getitem__(self, index):
    method __len__ (line 206) | def __len__(self):
    method inverse_transform (line 209) | def inverse_transform(self, data):
  class Dataset_Custom (line 213) | class Dataset_Custom(Dataset):
    method __init__ (line 214) | def __init__(self, args, root_path, flag='train', size=None,
    method __read_data__ (line 243) | def __read_data__(self):
    method __getitem__ (line 310) | def __getitem__(self, index):
    method __len__ (line 323) | def __len__(self):
    method inverse_transform (line 326) | def inverse_transform(self, data):
  class Dataset_M4 (line 330) | class Dataset_M4(Dataset):
    method __init__ (line 331) | def __init__(self, args, root_path, flag='pred', size=None,
    method __read_data__ (line 355) | def __read_data__(self):
    method __getitem__ (line 367) | def __getitem__(self, index):
    method __len__ (line 387) | def __len__(self):
    method inverse_transform (line 390) | def inverse_transform(self, data):
    method last_insample_window (line 393) | def last_insample_window(self):
  class PSMSegLoader (line 409) | class PSMSegLoader(Dataset):
    method __init__ (line 410) | def __init__(self, args, root_path, win_size, step=1, flag="train"):
    method __len__ (line 431) | def __len__(self):
    method __getitem__ (line 441) | def __getitem__(self, index):
  class MSLSegLoader (line 456) | class MSLSegLoader(Dataset):
    method __init__ (line 457) | def __init__(self, args, root_path, win_size, step=1, flag="train"):
    method __len__ (line 474) | def __len__(self):
    method __getitem__ (line 484) | def __getitem__(self, index):
  class SMAPSegLoader (line 499) | class SMAPSegLoader(Dataset):
    method __init__ (line 500) | def __init__(self, args, root_path, win_size, step=1, flag="train"):
    method __len__ (line 517) | def __len__(self):
    method __getitem__ (line 528) | def __getitem__(self, index):
  class SMDSegLoader (line 543) | class SMDSegLoader(Dataset):
    method __init__ (line 544) | def __init__(self, args, root_path, win_size, step=100, flag="train"):
    method __len__ (line 559) | def __len__(self):
    method __getitem__ (line 569) | def __getitem__(self, index):
  class SWATSegLoader (line 584) | class SWATSegLoader(Dataset):
    method __init__ (line 585) | def __init__(self, args, root_path, win_size, step=1, flag="train"):
    method __len__ (line 608) | def __len__(self):
    method __getitem__ (line 621) | def __getitem__(self, index):
  class UEAloader (line 636) | class UEAloader(Dataset):
    method __init__ (line 653) | def __init__(self, args, root_path, file_list=None, limit_size=None, f...
    method load_all (line 677) | def load_all(self, root_path, file_list=None, flag=None):
    method load_single (line 706) | def load_single(self, filepath):
    method instance_norm (line 742) | def instance_norm(self, case):
    method __getitem__ (line 752) | def __getitem__(self, ind):
    method __len__ (line 767) | def __len__(self):

FILE: ts_forecasting_methods/Other_baselines/data_provider/data_loader_tempo.py
  class Dataset_ETT_hour (line 18) | class Dataset_ETT_hour(Dataset):
    method __init__ (line 19) | def __init__(self, root_path, flag='train', size=None,
    method stl_resolve (line 55) | def stl_resolve(self, data_raw, data_name):
    method __read_data__ (line 110) | def __read_data__(self):
    method __getitem__ (line 165) | def __getitem__(self, index):
    method __len__ (line 182) | def __len__(self):
    method inverse_transform (line 185) | def inverse_transform(self, data):
  class Dataset_ETT_minute (line 189) | class Dataset_ETT_minute(Dataset):
    method __init__ (line 190) | def __init__(self, root_path, flag='train', size=None,
    method stl_resolve (line 224) | def stl_resolve(self, data_raw, data_name):
    method __read_data__ (line 281) | def __read_data__(self):
    method __getitem__ (line 334) | def __getitem__(self, index):
    method __len__ (line 351) | def __len__(self):
    method inverse_transform (line 354) | def inverse_transform(self, data):
  class Dataset_Custom (line 358) | class Dataset_Custom(Dataset):
    method __init__ (line 359) | def __init__(self, root_path, flag='train', size=None,
    method stl_resolve (line 394) | def stl_resolve(self, data_raw):
    method __read_data__ (line 453) | def __read_data__(self):
    method __getitem__ (line 528) | def __getitem__(self, index):
    method __len__ (line 549) | def __len__(self):
    method inverse_transform (line 553) | def inverse_transform(self, data):
  class Dataset_Pred (line 557) | class Dataset_Pred(Dataset):
    method __init__ (line 558) | def __init__(self, root_path, flag='pred', size=None,
    method stl_resolve (line 588) | def stl_resolve(self, data_raw, period=24):
    method __read_data__ (line 647) | def __read_data__(self):
    method __getitem__ (line 710) | def __getitem__(self, index):
    method __len__ (line 731) | def __len__(self):
    method inverse_transform (line 734) | def inverse_transform(self, data):
  class Dataset_TSF (line 738) | class Dataset_TSF(Dataset):
    method __init__ (line 739) | def __init__(self, root_path, flag='train', size=None,
    method __read_data__ (line 760) | def __read_data__(self):
    method __getitem__ (line 802) | def __getitem__(self, index):
    method __len__ (line 833) | def __len__(self):

FILE: ts_forecasting_methods/Other_baselines/data_provider/m4.py
  function url_file_name (line 35) | def url_file_name(url: str) -> str:
  function download (line 45) | def download(url: str, file_path: str) -> None:
  class M4Dataset (line 74) | class M4Dataset:
    method load (line 82) | def load(training: bool = True, dataset_file: str = '../dataset/m4') -...
  class M4Meta (line 102) | class M4Meta:
  function load_m4_info (line 132) | def load_m4_info() -> pd.DataFrame:

FILE: ts_forecasting_methods/Other_baselines/data_provider/uea.py
  function collate_fn (line 7) | def collate_fn(data, max_len=None):
  function padding_mask (line 45) | def padding_mask(lengths, max_len=None):
  class Normalizer (line 58) | class Normalizer(object):
    method __init__ (line 63) | def __init__(self, norm_type='standardization', mean=None, std=None, m...
    method normalize (line 78) | def normalize(self, df):
  function interpolate_missing (line 110) | def interpolate_missing(y):
  function subsample (line 119) | def subsample(y, limit=256, factor=2):

FILE: ts_forecasting_methods/Other_baselines/exp/exp_basic.py
  class Exp_Basic (line 6) | class Exp_Basic(object):
    method __init__ (line 7) | def __init__(self, args):
    method _build_model (line 23) | def _build_model(self):
    method _acquire_device (line 27) | def _acquire_device(self):
    method _get_data (line 38) | def _get_data(self):
    method vali (line 41) | def vali(self):
    method train (line 44) | def train(self):
    method test (line 47) | def test(self):

FILE: ts_forecasting_methods/Other_baselines/exp/exp_basic_patch.py
  class Exp_Basic (line 6) | class Exp_Basic(object):
    method __init__ (line 7) | def __init__(self, args):
    method _build_model (line 12) | def _build_model(self):
    method _acquire_device (line 16) | def _acquire_device(self):
    method _get_data (line 27) | def _get_data(self):
    method vali (line 30) | def vali(self):
    method train (line 33) | def train(self):
    method test (line 36) | def test(self):

FILE: ts_forecasting_methods/Other_baselines/exp/exp_long_term_forecasting.py
  class Exp_Long_Term_Forecast (line 17) | class Exp_Long_Term_Forecast(Exp_Basic):
    method __init__ (line 18) | def __init__(self, args):
    method _build_model (line 21) | def _build_model(self):
    method _get_data (line 28) | def _get_data(self, flag):
    method _select_optimizer (line 32) | def _select_optimizer(self):
    method _select_criterion (line 36) | def _select_criterion(self):
    method vali (line 40) | def vali(self, vali_data, vali_loader, criterion):
    method train (line 80) | def train(self, setting):
    method test (line 181) | def test(self, setting, test=0):

FILE: ts_forecasting_methods/Other_baselines/exp/exp_main.py
  function adjust_learning_rate (line 23) | def adjust_learning_rate(optimizer, scheduler, epoch, args, printout=True):
  class Exp_Main (line 54) | class Exp_Main(Exp_Basic):
    method __init__ (line 55) | def __init__(self, args):
    method _build_model (line 58) | def _build_model(self):
    method _get_data (line 68) | def _get_data(self, flag):
    method _select_optimizer (line 72) | def _select_optimizer(self):
    method _select_criterion (line 76) | def _select_criterion(self):
    method vali (line 80) | def vali(self, vali_data, vali_loader, criterion):
    method train (line 126) | def train(self, setting):
    method test (line 245) | def test(self, setting, test=0):
    method predict (line 354) | def predict(self, setting, load=False):

FILE: ts_forecasting_methods/Other_baselines/exp/exp_short_term_forecasting.py
  class Exp_Short_Term_Forecast (line 19) | class Exp_Short_Term_Forecast(Exp_Basic):
    method __init__ (line 20) | def __init__(self, args):
    method _build_model (line 23) | def _build_model(self):
    method _get_data (line 35) | def _get_data(self, flag):
    method _select_optimizer (line 39) | def _select_optimizer(self):
    method _select_criterion (line 43) | def _select_criterion(self, loss_name='MSE'):
    method train (line 53) | def train(self, setting):
    method vali (line 129) | def vali(self, train_loader, vali_loader, criterion):
    method test (line 160) | def test(self, setting, test=0):

FILE: ts_forecasting_methods/Other_baselines/layers/AutoCorrelation.py
  class AutoCorrelation (line 11) | class AutoCorrelation(nn.Module):
    method __init__ (line 19) | def __init__(self, mask_flag=True, factor=1, scale=None, attention_dro...
    method time_delay_agg_training (line 27) | def time_delay_agg_training(self, values, corr):
    method time_delay_agg_inference (line 51) | def time_delay_agg_inference(self, values, corr):
    method time_delay_agg_full (line 78) | def time_delay_agg_full(self, values, corr):
    method forward (line 102) | def forward(self, queries, keys, values, attn_mask):
  class AutoCorrelationLayer (line 131) | class AutoCorrelationLayer(nn.Module):
    method __init__ (line 132) | def __init__(self, correlation, d_model, n_heads, d_keys=None,
    method forward (line 146) | def forward(self, queries, keys, values, attn_mask):

FILE: ts_forecasting_methods/Other_baselines/layers/Autoformer_EncDec.py
  class my_Layernorm (line 6) | class my_Layernorm(nn.Module):
    method __init__ (line 11) | def __init__(self, channels):
    method forward (line 15) | def forward(self, x):
  class moving_avg (line 21) | class moving_avg(nn.Module):
    method __init__ (line 26) | def __init__(self, kernel_size, stride):
    method forward (line 31) | def forward(self, x):
  class series_decomp (line 41) | class series_decomp(nn.Module):
    method __init__ (line 46) | def __init__(self, kernel_size):
    method forward (line 50) | def forward(self, x):
  class series_decomp_multi (line 56) | class series_decomp_multi(nn.Module):
    method __init__ (line 61) | def __init__(self, kernel_size):
    method forward (line 66) | def forward(self, x):
  class EncoderLayer (line 79) | class EncoderLayer(nn.Module):
    method __init__ (line 84) | def __init__(self, attention, d_model, d_ff=None, moving_avg=25, dropo...
    method forward (line 95) | def forward(self, x, attn_mask=None):
  class Encoder (line 109) | class Encoder(nn.Module):
    method __init__ (line 114) | def __init__(self, attn_layers, conv_layers=None, norm_layer=None):
    method forward (line 120) | def forward(self, x, attn_mask=None):
  class DecoderLayer (line 140) | class DecoderLayer(nn.Module):
    method __init__ (line 145) | def __init__(self, self_attention, cross_attention, d_model, c_out, d_...
    method forward (line 161) | def forward(self, x, cross, x_mask=None, cross_mask=None):
  class Decoder (line 182) | class Decoder(nn.Module):
    method __init__ (line 187) | def __init__(self, layers, norm_layer=None, projection=None):
    method forward (line 193) | def forward(self, x, cross, x_mask=None, cross_mask=None, trend=None):

FILE: ts_forecasting_methods/Other_baselines/layers/Conv_Blocks.py
  class Inception_Block_V1 (line 5) | class Inception_Block_V1(nn.Module):
    method __init__ (line 6) | def __init__(self, in_channels, out_channels, num_kernels=6, init_weig...
    method _initialize_weights (line 18) | def _initialize_weights(self):
    method forward (line 25) | def forward(self, x):
  class Inception_Block_V2 (line 33) | class Inception_Block_V2(nn.Module):
    method __init__ (line 34) | def __init__(self, in_channels, out_channels, num_kernels=6, init_weig...
    method _initialize_weights (line 48) | def _initialize_weights(self):
    method forward (line 55) | def forward(self, x):

FILE: ts_forecasting_methods/Other_baselines/layers/Embed.py
  class PositionalEmbedding (line 8) | class PositionalEmbedding(nn.Module):
    method __init__ (line 9) | def __init__(self, d_model, max_len=5000):
    method forward (line 25) | def forward(self, x):
  class TokenEmbedding (line 29) | class TokenEmbedding(nn.Module):
    method __init__ (line 30) | def __init__(self, c_in, d_model):
    method forward (line 40) | def forward(self, x):
  class FixedEmbedding (line 45) | class FixedEmbedding(nn.Module):
    method __init__ (line 46) | def __init__(self, c_in, d_model):
    method forward (line 62) | def forward(self, x):
  class TemporalEmbedding (line 66) | class TemporalEmbedding(nn.Module):
    method __init__ (line 67) | def __init__(self, d_model, embed_type='fixed', freq='h'):
    method forward (line 84) | def forward(self, x):
  class TimeFeatureEmbedding (line 96) | class TimeFeatureEmbedding(nn.Module):
    method __init__ (line 97) | def __init__(self, d_model, embed_type='timeF', freq='h'):
    method forward (line 105) | def forward(self, x):
  class DataEmbedding (line 109) | class DataEmbedding(nn.Module):
    method __init__ (line 110) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 120) | def forward(self, x, x_mark):
  class DataEmbedding_inverted (line 129) | class DataEmbedding_inverted(nn.Module):
    method __init__ (line 130) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 135) | def forward(self, x, x_mark):
  class DataEmbedding_wo_pos (line 146) | class DataEmbedding_wo_pos(nn.Module):
    method __init__ (line 147) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 157) | def forward(self, x, x_mark):
  class PatchEmbedding (line 165) | class PatchEmbedding(nn.Module):
    method __init__ (line 166) | def __init__(self, d_model, patch_len, stride, padding, dropout):
    method forward (line 182) | def forward(self, x):
  class DataEmbedding_wo_time (line 193) | class DataEmbedding_wo_time(nn.Module):
    method __init__ (line 194) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 201) | def forward(self, x):

FILE: ts_forecasting_methods/Other_baselines/layers/PatchTST_backbone.py
  class PatchTST_backbone (line 14) | class PatchTST_backbone(nn.Module):
    method __init__ (line 15) | def __init__(self, c_in:int, context_window:int, target_window:int, pa...
    method forward (line 58) | def forward(self, z):                                                 ...
    method create_pretrain_head (line 82) | def create_pretrain_head(self, head_nf, vars, dropout):
  class Flatten_Head (line 88) | class Flatten_Head(nn.Module):
    method __init__ (line 89) | def __init__(self, individual, n_vars, nf, target_window, head_dropout...
    method forward (line 108) | def forward(self, x):                                 # x: [bs x nvars...
  class TSTiEncoder (line 126) | class TSTiEncoder(nn.Module):  #i means channel-independent
    method __init__ (line 127) | def __init__(self, c_in, patch_num, patch_len, max_seq_len=1024,
    method forward (line 155) | def forward(self, x) -> Tensor:                                       ...
  class TSTEncoder (line 175) | class TSTEncoder(nn.Module):
    method __init__ (line 176) | def __init__(self, q_len, d_model, n_heads, d_k=None, d_v=None, d_ff=N...
    method forward (line 187) | def forward(self, src:Tensor, key_padding_mask:Optional[Tensor]=None, ...
  class TSTEncoderLayer (line 199) | class TSTEncoderLayer(nn.Module):
    method __init__ (line 200) | def __init__(self, q_len, d_model, n_heads, d_k=None, d_v=None, d_ff=2...
    method forward (line 235) | def forward(self, src:Tensor, prev:Optional[Tensor]=None, key_padding_...
  class _MultiheadAttention (line 270) | class _MultiheadAttention(nn.Module):
    method __init__ (line 271) | def __init__(self, d_model, n_heads, d_k=None, d_v=None, res_attention...
    method forward (line 296) | def forward(self, Q:Tensor, K:Optional[Tensor]=None, V:Optional[Tensor...
  class _ScaledDotProductAttention (line 323) | class _ScaledDotProductAttention(nn.Module):
    method __init__ (line 328) | def __init__(self, d_model, n_heads, attn_dropout=0., res_attention=Fa...
    method forward (line 336) | def forward(self, q:Tensor, k:Tensor, v:Tensor, prev:Optional[Tensor]=...

FILE: ts_forecasting_methods/Other_baselines/layers/PatchTST_layers.py
  class Transpose (line 5) | class Transpose(nn.Module):
    method __init__ (line 6) | def __init__(self, *dims, contiguous=False):
    method forward (line 9) | def forward(self, x):
  function get_activation_fn (line 14) | def get_activation_fn(activation):
  class moving_avg (line 23) | class moving_avg(nn.Module):
    method __init__ (line 27) | def __init__(self, kernel_size, stride):
    method forward (line 32) | def forward(self, x):
  class series_decomp (line 42) | class series_decomp(nn.Module):
    method __init__ (line 46) | def __init__(self, kernel_size):
    method forward (line 50) | def forward(self, x):
  function PositionalEncoding (line 59) | def PositionalEncoding(q_len, d_model, normalize=True):
  function Coord2dPosEncoding (line 72) | def Coord2dPosEncoding(q_len, d_model, exponential=False, normalize=True...
  function Coord1dPosEncoding (line 87) | def Coord1dPosEncoding(q_len, exponential=False, normalize=True):
  function positional_encoding (line 94) | def positional_encoding(pe, learn_pe, q_len, d_model):

FILE: ts_forecasting_methods/Other_baselines/layers/RevIN.py
  class RevIN (line 6) | class RevIN(nn.Module):
    method __init__ (line 7) | def __init__(self, num_features: int, eps=1e-5, affine=True, subtract_...
    method forward (line 21) | def forward(self, x, mode:str):
    method _init_params (line 30) | def _init_params(self):
    method _get_statistics (line 35) | def _get_statistics(self, x):
    method _normalize (line 43) | def _normalize(self, x):
    method _denormalize (line 54) | def _denormalize(self, x):

FILE: ts_forecasting_methods/Other_baselines/layers/SelfAttention_Family.py
  class DSAttention (line 10) | class DSAttention(nn.Module):
    method __init__ (line 13) | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dro...
    method forward (line 20) | def forward(self, queries, keys, values, attn_mask, tau=None, delta=No...
  class FullAttention (line 48) | class FullAttention(nn.Module):
    method __init__ (line 49) | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dro...
    method forward (line 56) | def forward(self, queries, keys, values, attn_mask, tau=None, delta=No...
  class ProbAttention (line 78) | class ProbAttention(nn.Module):
    method __init__ (line 79) | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dro...
    method _prob_QK (line 87) | def _prob_QK(self, Q, K, sample_k, n_top):  # n_top: c*ln(L_q)
    method _get_initial_context (line 113) | def _get_initial_context(self, V, L_Q):
    method _update_context (line 126) | def _update_context(self, context_in, V, scores, index, L_Q, attn_mask):
    method forward (line 147) | def forward(self, queries, keys, values, attn_mask, tau=None, delta=No...
  class AttentionLayer (line 179) | class AttentionLayer(nn.Module):
    method __init__ (line 180) | def __init__(self, attention, d_model, n_heads, d_keys=None,
    method forward (line 194) | def forward(self, queries, keys, values, attn_mask, tau=None, delta=No...
  class ReformerLayer (line 216) | class ReformerLayer(nn.Module):
    method __init__ (line 217) | def __init__(self, attention, d_model, n_heads, d_keys=None,
    method fit_length (line 229) | def fit_length(self, queries):
    method forward (line 239) | def forward(self, queries, keys, values, attn_mask, tau, delta):
  class TwoStageAttentionLayer (line 246) | class TwoStageAttentionLayer(nn.Module):
    method __init__ (line 252) | def __init__(self, configs,
    method forward (line 278) | def forward(self, x, attn_mask=None, tau=None, delta=None):

FILE: ts_forecasting_methods/Other_baselines/layers/Transformer_EncDec.py
  class ConvLayer (line 6) | class ConvLayer(nn.Module):
    method __init__ (line 7) | def __init__(self, c_in):
    method forward (line 18) | def forward(self, x):
  class EncoderLayer (line 27) | class EncoderLayer(nn.Module):
    method __init__ (line 28) | def __init__(self, attention, d_model, d_ff=None, dropout=0.1, activat...
    method forward (line 39) | def forward(self, x, attn_mask=None, tau=None, delta=None):
  class Encoder (line 54) | class Encoder(nn.Module):
    method __init__ (line 55) | def __init__(self, attn_layers, conv_layers=None, norm_layer=None):
    method forward (line 61) | def forward(self, x, attn_mask=None, tau=None, delta=None):
  class DecoderLayer (line 83) | class DecoderLayer(nn.Module):
    method __init__ (line 84) | def __init__(self, self_attention, cross_attention, d_model, d_ff=None,
    method forward (line 98) | def forward(self, x, cross, x_mask=None, cross_mask=None, tau=None, de...
  class Decoder (line 119) | class Decoder(nn.Module):
    method __init__ (line 120) | def __init__(self, layers, norm_layer=None, projection=None):
    method forward (line 126) | def forward(self, x, cross, x_mask=None, cross_mask=None, tau=None, de...

FILE: ts_forecasting_methods/Other_baselines/models/Autoformer.py
  class Model (line 11) | class Model(nn.Module):
    method __init__ (line 18) | def __init__(self, configs):
    method forecast (line 89) | def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
    method imputation (line 112) | def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask):
    method anomaly_detection (line 120) | def anomaly_detection(self, x_enc):
    method classification (line 128) | def classification(self, x_enc, x_mark_enc):
    method forward (line 144) | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):

FILE: ts_forecasting_methods/Other_baselines/models/DLinear.py
  class Model (line 7) | class Model(nn.Module):
    method __init__ (line 12) | def __init__(self, configs, individual=False):
    method encoder (line 55) | def encoder(self, x):
    method forecast (line 75) | def forecast(self, x_enc):
    method imputation (line 79) | def imputation(self, x_enc):
    method anomaly_detection (line 83) | def anomaly_detection(self, x_enc):
    method classification (line 87) | def classification(self, x_enc):
    method forward (line 97) | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):

FILE: ts_forecasting_methods/Other_baselines/models/GPT4TS.py
  class GPT4TS (line 10) | class GPT4TS(nn.Module):
    method __init__ (line 12) | def __init__(self, configs, device):
    method forward (line 58) | def forward(self, x, itr):

FILE: ts_forecasting_methods/Other_baselines/models/Informer.py
  class Model (line 9) | class Model(nn.Module):
    method __init__ (line 15) | def __init__(self, configs):
    method long_forecast (line 77) | def long_forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
    method short_forecast (line 86) | def short_forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
    method imputation (line 102) | def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask):
    method anomaly_detection (line 110) | def anomaly_detection(self, x_enc):
    method classification (line 118) | def classification(self, x_enc, x_mark_enc):
    method forward (line 131) | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):

FILE: ts_forecasting_methods/Other_baselines/models/LogTrans.py
  function _make_ix_like (line 40) | def _make_ix_like(X, dim):
  function _roll_last (line 48) | def _roll_last(X, dim):
  function _entmax_threshold_and_support (line 59) | def _entmax_threshold_and_support(X, dim=-1, k=None):
  class Entmax15Function (line 113) | class Entmax15Function(Function):
    method forward (line 115) | def forward(cls, ctx, X: torch.Tensor, dim=0, k=None):
    method backward (line 129) | def backward(cls, ctx, dY):
  function entmax15 (line 139) | def entmax15(X, dim=-1, k=None):
  function _sparsemax_threshold_and_support (line 165) | def _sparsemax_threshold_and_support(X, dim=-1, k=None):
  class SparsemaxFunction (line 212) | class SparsemaxFunction(Function):
    method forward (line 214) | def forward(cls, ctx, X, dim=-1, k=None):
    method backward (line 224) | def backward(cls, ctx, grad_output):
  function sparsemax (line 236) | def sparsemax(X, dim=-1, k=None):
  class Sparsemax (line 261) | class Sparsemax(nn.Module):
    method __init__ (line 262) | def __init__(self, dim=-1, k=None):
    method forward (line 281) | def forward(self, X):
  function swish (line 285) | def swish(x):
  function gelu (line 294) | def gelu(x):
  function swish (line 298) | def swish(x):
  class Attention (line 308) | class Attention(nn.Module):
    method __init__ (line 309) | def __init__(self, n_head, n_embd, win_len, scale, q_len, sub_len, spa...
    method log_mask (line 329) | def log_mask(self, win_len, sub_len):
    method row_mask (line 335) | def row_mask(self, index, sub_len, win_len):
    method attn (line 363) | def attn(self, query: torch.Tensor, key, value: torch.Tensor, activati...
    method merge_heads (line 376) | def merge_heads(self, x):
    method split_heads (line 381) | def split_heads(self, x, k=False):
    method forward (line 389) | def forward(self, x):
  class Conv1D (line 405) | class Conv1D(nn.Module):
    method __init__ (line 406) | def __init__(self, out_dim, rf, in_dim):
    method forward (line 418) | def forward(self, x):
  class LayerNorm (line 435) | class LayerNorm(nn.Module):
    method __init__ (line 438) | def __init__(self, n_embd, e=1e-5):
    method forward (line 444) | def forward(self, x):
  class MLP (line 451) | class MLP(nn.Module):
    method __init__ (line 452) | def __init__(self, n_state, n_embd, acf='relu'):
    method forward (line 460) | def forward(self, x):
  class Block (line 466) | class Block(nn.Module):
    method __init__ (line 467) | def __init__(self, n_head, win_len, n_embd, scale, q_len, sub_len):
    method forward (line 475) | def forward(self, x):
  class TransformerModel (line 483) | class TransformerModel(nn.Module):
    method __init__ (line 486) | def __init__(self, n_time_series, n_head, sub_len, num_layer, n_embd,
    method forward (line 513) | def forward(self, series_id: int, x: torch.Tensor):
  class Model (line 543) | class Model(nn.Module):
    method __init__ (line 544) | def __init__(self, configs):
    method _initialize_weights (line 583) | def _initialize_weights(self):
    method forward (line 593) | def forward(self, x: torch.Tensor, x_mark_enc, x_dec, x_mark_dec,

FILE: ts_forecasting_methods/Other_baselines/models/PatchTST.py
  function l2norm (line 10) | def l2norm(t):
  class AttentionLayer (line 13) | class AttentionLayer(nn.Module):
    method __init__ (line 14) | def __init__(self, attention, d_model, n_heads, d_keys=None, d_values=...
    method forward (line 27) | def forward(self, queries, keys, values, attn_mask, attn_bias):
  class FullAttention (line 47) | class FullAttention(nn.Module):
    method __init__ (line 48) | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dro...
    method forward (line 60) | def forward(self, queries, keys, values, attn_mask, attn_bias):
  class EncoderLayer (line 84) | class EncoderLayer(nn.Module):
    method __init__ (line 85) | def __init__(self, attention, d_model, d_ff=None, dropout=0.1, activat...
    method forward (line 96) | def forward(self, x, attn_mask=None, attn_bias=None):
  class Encoder (line 110) | class Encoder(nn.Module):
    method __init__ (line 111) | def __init__(self, attn_layers, conv_layers=None, norm_layer=None):
    method forward (line 117) | def forward(self, x, attn_mask=None, attn_bias=None):
  class PatchTST (line 138) | class PatchTST(nn.Module):
    method __init__ (line 142) | def __init__(self, configs, device):
    method forward (line 184) | def forward(self, x_enc, itr):

FILE: ts_forecasting_methods/Other_baselines/models/PatchTST_raw.py
  class Model (line 13) | class Model(nn.Module):
    method __init__ (line 14) | def __init__(self, configs, max_seq_len: Optional[int] = 1024, d_k: Op...
    method forward (line 97) | def forward(self, x):  # x: [Batch, Input length, Channel]

FILE: ts_forecasting_methods/Other_baselines/models/TCN.py
  class Chomp1d (line 14) | class Chomp1d(nn.Module):
    method __init__ (line 15) | def __init__(self, chomp_size):
    method forward (line 19) | def forward(self, x):
  class TemporalBlock (line 23) | class TemporalBlock(nn.Module):
    method __init__ (line 24) | def __init__(self, n_inputs, n_outputs, kernel_size, stride, dilation,...
    method init_weights (line 44) | def init_weights(self):
    method forward (line 50) | def forward(self, x):
  class TemporalConvNet (line 56) | class TemporalConvNet(nn.Module):
    method __init__ (line 57) | def __init__(self, num_inputs, num_channels, kernel_size=2, dropout=0.2):
    method forward (line 70) | def forward(self, x):
  class Model (line 75) | class Model(nn.Module):
    method __init__ (line 77) | def __init__(self, configs):
    method init_weights (line 90) | def init_weights(self):
    method forward (line 93) | def forward(self, x, x_mark_enc=None, x_dec=None, x_mark_dec=None, mas...

FILE: ts_forecasting_methods/Other_baselines/models/TEMPO.py
  class ComplexLinear (line 15) | class ComplexLinear(nn.Module):
    method __init__ (line 16) | def __init__(self, input_dim, output_dim):
    method forward (line 21) | def forward(self, x):
  function print_trainable_parameters (line 29) | def print_trainable_parameters(model):
  class MultiFourier (line 40) | class MultiFourier(torch.nn.Module):
    method __init__ (line 41) | def __init__(self, N, P):
    method forward (line 48) | def forward(self, t):
  class moving_avg (line 59) | class moving_avg(nn.Module):
    method __init__ (line 63) | def __init__(self, kernel_size, stride):
    method forward (line 68) | def forward(self, x):
  class TEMPO (line 77) | class TEMPO(nn.Module):
    method __init__ (line 79) | def __init__(self, configs, device):
    method store_tensors_in_dict (line 251) | def store_tensors_in_dict(self, original_x, original_trend, original_s...
    method l2_normalize (line 267) | def l2_normalize(self, x, dim=None, epsilon=1e-12):
    method select_prompt (line 273) | def select_prompt(self, summary, prompt_mask=None):
    method get_norm (line 308) | def get_norm(self, x, d = 'norm'):
    method get_patch (line 317) | def get_patch(self, x):
    method get_emb (line 325) | def get_emb(self, x, tokens=None, type = 'Trend'):
    method forward (line 385) | def forward(self, x, itr, trend, season, noise, test=False):

FILE: ts_forecasting_methods/Other_baselines/models/TimesNet.py
  function FFT_for_Period (line 9) | def FFT_for_Period(x, k=2):
  class TimesBlock (line 21) | class TimesBlock(nn.Module):
    method __init__ (line 22) | def __init__(self, configs):
    method forward (line 36) | def forward(self, x):
  class Model (line 71) | class Model(nn.Module):
    method __init__ (line 76) | def __init__(self, configs):
    method forecast (line 103) | def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
    method imputation (line 130) | def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask):
    method anomaly_detection (line 158) | def anomaly_detection(self, x_enc):
    method classification (line 183) | def classification(self, x_enc, x_mark_enc):
    method forward (line 201) | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):

FILE: ts_forecasting_methods/Other_baselines/models/iTransformer.py
  class Model (line 10) | class Model(nn.Module):
    method __init__ (line 15) | def __init__(self, configs):
    method forecast (line 51) | def forecast(self, x_enc, x_mark_enc, x_dec, x_mark_dec):
    method imputation (line 70) | def imputation(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask):
    method anomaly_detection (line 89) | def anomaly_detection(self, x_enc):
    method classification (line 108) | def classification(self, x_enc, x_mark_enc):
    method forward (line 120) | def forward(self, x_enc, x_mark_enc, x_dec, x_mark_dec, mask=None):

FILE: ts_forecasting_methods/Other_baselines/train_cost.py
  function generate_pred_samples (line 25) | def generate_pred_samples(features, data, pred_len, drop=0):
  function cal_metrics (line 35) | def cal_metrics(pred, target):
  function eval_forecasting (line 42) | def eval_forecasting(model, train_data, valid_data, test_data, pred_lens...
  function save_checkpoint_callback (line 129) | def save_checkpoint_callback(

FILE: ts_forecasting_methods/Other_baselines/train_gpt4ts.py
  class SMAPE (line 164) | class SMAPE(nn.Module):
    method __init__ (line 165) | def __init__(self):
    method forward (line 168) | def forward(self, pred, true):

FILE: ts_forecasting_methods/Other_baselines/train_tempo.py
  function get_init_config (line 34) | def get_init_config(config_path=None):
  class SMAPE (line 287) | class SMAPE(nn.Module):
    method __init__ (line 288) | def __init__(self):
    method forward (line 291) | def forward(self, pred, true):

FILE: ts_forecasting_methods/Other_baselines/train_ts2vec.py
  function generate_pred_samples (line 23) | def generate_pred_samples(features, data, pred_len, drop=0):
  function cal_metrics (line 33) | def cal_metrics(pred, target):
  function eval_forecasting_new (line 40) | def eval_forecasting_new(model, train_data, valid_data, test_data, pred_...
  function save_checkpoint_callback (line 134) | def save_checkpoint_callback(

FILE: ts_forecasting_methods/Other_baselines/utils/ADFtest.py
  function calculate_ADF (line 7) | def calculate_ADF(root_path,data_path):
  function calculate_target_ADF (line 20) | def calculate_target_ADF(root_path,data_path,target='OT'):
  function archADF (line 33) | def archADF(root_path, data_path):

FILE: ts_forecasting_methods/Other_baselines/utils/augmentation.py
  function jitter (line 4) | def jitter(x, sigma=0.03):
  function scaling (line 9) | def scaling(x, sigma=0.1):
  function rotation (line 14) | def rotation(x):
  function permutation (line 21) | def permutation(x, max_segments=5, seg_mode="equal"):
  function magnitude_warp (line 46) | def magnitude_warp(x, sigma=0.2, knot=4):
  function time_warp (line 59) | def time_warp(x, sigma=0.2, knot=4):
  function window_slice (line 74) | def window_slice(x, reduce_ratio=0.9):
  function window_warp (line 88) | def window_warp(x, window_ratio=0.1, scales=[0.5, 2.]):
  function spawner (line 107) | def spawner(x, labels, sigma=0.05, verbose=0):
  function wdba (line 145) | def wdba(x, labels, batch_size=6, slope_constraint="symmetric", use_wind...
  function random_guided_warp (line 207) | def random_guided_warp(x, labels, slope_constraint="symmetric", use_wind...
  function random_guided_warp_shape (line 247) | def random_guided_warp_shape(x, labels, slope_constraint="symmetric", us...
  function discriminative_guided_warp (line 250) | def discriminative_guided_warp(x, labels, batch_size=6, slope_constraint...
  function discriminative_guided_warp_shape (line 328) | def discriminative_guided_warp_shape(x, labels, batch_size=6, slope_cons...
  function run_augmentation (line 332) | def run_augmentation(x, y, args):
  function run_augmentation_single (line 350) | def run_augmentation_single(x, y, args):
  function augment (line 368) | def augment(x, y, args):

FILE: ts_forecasting_methods/Other_baselines/utils/dtw.py
  function _traceback (line 12) | def _traceback(DTW, slope_constraint):
  function dtw (line 50) | def dtw(prototype, sample, return_flag = RETURN_VALUE, slope_constraint=...
  function _cummulative_matrix (line 79) | def _cummulative_matrix(cost, slope_constraint, window):
  function shape_dtw (line 103) | def shape_dtw(prototype, sample, return_flag = RETURN_VALUE, slope_const...
  function draw_graph2d (line 149) | def draw_graph2d(cost, DTW, path, prototype, sample):
  function draw_graph1d (line 186) | def draw_graph1d(cost, DTW, path, prototype, sample):

FILE: ts_forecasting_methods/Other_baselines/utils/dtw_metric.py
  function dtw (line 6) | def dtw(x, y, dist, warp=1, w=inf, s=1.0):
  function accelerated_dtw (line 58) | def accelerated_dtw(x, y, dist, warp=1):
  function _traceback (line 100) | def _traceback(D):

FILE: ts_forecasting_methods/Other_baselines/utils/losses.py
  function divide_no_nan (line 25) | def divide_no_nan(a, b):
  class mape_loss (line 35) | class mape_loss(nn.Module):
    method __init__ (line 36) | def __init__(self):
    method forward (line 39) | def forward(self, insample: t.Tensor, freq: int,
  class smape_loss (line 53) | class smape_loss(nn.Module):
    method __init__ (line 54) | def __init__(self):
    method forward (line 57) | def forward(self, insample: t.Tensor, freq: int,
  class mase_loss (line 71) | class mase_loss(nn.Module):
    method __init__ (line 72) | def __init__(self):
    method forward (line 75) | def forward(self, insample: t.Tensor, freq: int,

FILE: ts_forecasting_methods/Other_baselines/utils/m4_summary.py
  function group_values (line 28) | def group_values(values, groups, group_name):
  function mase (line 32) | def mase(forecast, insample, outsample, frequency):
  function smape_2 (line 36) | def smape_2(forecast, target):
  function mape (line 43) | def mape(forecast, target):
  class M4Summary (line 50) | class M4Summary:
    method __init__ (line 51) | def __init__(self, file_path, root_path):
    method evaluate (line 57) | def evaluate(self):
    method summarize_groups (line 113) | def summarize_groups(self, scores):

FILE: ts_forecasting_methods/Other_baselines/utils/masking.py
  class TriangularCausalMask (line 4) | class TriangularCausalMask():
    method __init__ (line 5) | def __init__(self, B, L, device="cpu"):
    method mask (line 11) | def mask(self):
  class ProbMask (line 15) | class ProbMask():
    method __init__ (line 16) | def __init__(self, B, H, L, index, scores, device="cpu"):
    method mask (line 25) | def mask(self):

FILE: ts_forecasting_methods/Other_baselines/utils/metrics.py
  function RSE (line 4) | def RSE(pred, true):
  function CORR (line 8) | def CORR(pred, true):
  function MAE (line 14) | def MAE(pred, true):
  function MSE (line 18) | def MSE(pred, true):
  function RMSE (line 22) | def RMSE(pred, true):
  function MAPE (line 26) | def MAPE(pred, true):
  function MSPE (line 30) | def MSPE(pred, true):
  function metric (line 34) | def metric(pred, true):

FILE: ts_forecasting_methods/Other_baselines/utils/print_args.py
  function print_args (line 1) | def print_args(args):

FILE: ts_forecasting_methods/Other_baselines/utils/rev_in.py
  class RevIn (line 12) | class RevIn(nn.Module):
    method __init__ (line 13) | def __init__(self, num_features: int, eps=1e-5, affine=True, subtract_...
    method forward (line 29) | def forward(self, x, mode: str):
    method _init_params (line 42) | def _init_params(self):
    method _get_statistics (line 47) | def _get_statistics(self, x):
    method _normalize (line 55) | def _normalize(self, x):
    method _denormalize (line 66) | def _denormalize(self, x):

FILE: ts_forecasting_methods/Other_baselines/utils/timefeatures.py
  class TimeFeature (line 23) | class TimeFeature:
    method __init__ (line 24) | def __init__(self):
    method __call__ (line 27) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
    method __repr__ (line 30) | def __repr__(self):
  class SecondOfMinute (line 34) | class SecondOfMinute(TimeFeature):
    method __call__ (line 37) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class MinuteOfHour (line 41) | class MinuteOfHour(TimeFeature):
    method __call__ (line 44) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class HourOfDay (line 48) | class HourOfDay(TimeFeature):
    method __call__ (line 51) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class DayOfWeek (line 55) | class DayOfWeek(TimeFeature):
    method __call__ (line 58) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class DayOfMonth (line 62) | class DayOfMonth(TimeFeature):
    method __call__ (line 65) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class DayOfYear (line 69) | class DayOfYear(TimeFeature):
    method __call__ (line 72) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class MonthOfYear (line 76) | class MonthOfYear(TimeFeature):
    method __call__ (line 79) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class WeekOfYear (line 83) | class WeekOfYear(TimeFeature):
    method __call__ (line 86) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  function time_features_from_frequency_str (line 90) | def time_features_from_frequency_str(freq_str: str) -> List[TimeFeature]:
  function time_features (line 147) | def time_features(dates, freq='h'):

FILE: ts_forecasting_methods/Other_baselines/utils/tools.py
  function adjust_learning_rate (line 15) | def adjust_learning_rate(optimizer, epoch, args):
  class EarlyStopping (line 33) | class EarlyStopping:
    method __init__ (line 34) | def __init__(self, patience=7, verbose=False, delta=0):
    method __call__ (line 43) | def __call__(self, val_loss, model, path):
    method save_checkpoint (line 58) | def save_checkpoint(self, val_loss, model, path):
  class dotdict (line 65) | class dotdict(dict):
  class StandardScaler (line 72) | class StandardScaler():
    method __init__ (line 73) | def __init__(self, mean, std):
    method transform (line 77) | def transform(self, data):
    method inverse_transform (line 80) | def inverse_transform(self, data):
  function visual (line 84) | def visual(true, preds=None, name='./pic/test.pdf'):
  function adjustment (line 96) | def adjustment(gt, pred):
  function cal_accuracy (line 120) | def cal_accuracy(y_pred, y_true):
  function vali (line 124) | def vali(model, vali_data, vali_loader, criterion, args, device, itr):
  function MASE (line 160) | def MASE(x, freq, pred, true):
  function test (line 165) | def test(model, test_data, test_loader, args, device, itr):
  function convert_tsf_to_dataframe (line 210) | def convert_tsf_to_dataframe(
  function test_params_flop (line 355) | def test_params_flop(model,x_shape):

FILE: ts_forecasting_methods/Other_baselines/utils/tools_tempo.py
  function adjust_learning_rate (line 16) | def adjust_learning_rate(optimizer, epoch, args):
  class EarlyStopping (line 44) | class EarlyStopping:
    method __init__ (line 45) | def __init__(self, patience=7, verbose=False, delta=0):
    method __call__ (line 54) | def __call__(self, val_loss, model, path):
    method save_checkpoint (line 69) | def save_checkpoint(self, val_loss, model, path):
  class dotdict (line 76) | class dotdict(dict):
  class StandardScaler (line 83) | class StandardScaler():
    method __init__ (line 84) | def __init__(self, mean, std):
    method transform (line 88) | def transform(self, data):
    method inverse_transform (line 91) | def inverse_transform(self, data):
  function visual (line 95) | def visual(true, preds=None, name='./pic/test.pdf'):
  function convert_tsf_to_dataframe (line 107) | def convert_tsf_to_dataframe(
  function vali (line 252) | def vali(model, vali_data, vali_loader, criterion, args, device, itr):
  function MASE (line 320) | def MASE(x, freq, pred, true):
  function metric_mae_mse (line 325) | def metric_mae_mse(preds, trues):
  function test (line 331) | def test(model, test_data, test_loader, args, device, itr):

FILE: ts_forecasting_methods/SupervisedBaselines/data_provider/data_factory.py
  function data_provider (line 13) | def data_provider(args, flag):

FILE: ts_forecasting_methods/SupervisedBaselines/data_provider/data_loader.py
  class Dataset_ETT_hour (line 14) | class Dataset_ETT_hour(Dataset):
    method __init__ (line 15) | def __init__(self, root_path, flag='train', size=None,
    method __read_data__ (line 43) | def __read_data__(self):
    method __getitem__ (line 82) | def __getitem__(self, index):
    method __len__ (line 95) | def __len__(self):
    method inverse_transform (line 98) | def inverse_transform(self, data):
  class Dataset_ETT_minute (line 102) | class Dataset_ETT_minute(Dataset):
    method __init__ (line 103) | def __init__(self, root_path, flag='train', size=None,
    method __read_data__ (line 131) | def __read_data__(self):
    method __getitem__ (line 172) | def __getitem__(self, index):
    method __len__ (line 185) | def __len__(self):
    method inverse_transform (line 188) | def inverse_transform(self, data):
  class Dataset_Custom (line 192) | class Dataset_Custom(Dataset):
    method __init__ (line 193) | def __init__(self, root_path, flag='train', size=None,
    method __read_data__ (line 221) | def __read_data__(self):
    method __getitem__ (line 267) | def __getitem__(self, index):
    method __len__ (line 280) | def __len__(self):
    method inverse_transform (line 283) | def inverse_transform(self, data):
  class Dataset_Pred (line 287) | class Dataset_Pred(Dataset):
    method __init__ (line 288) | def __init__(self, root_path, flag='pred', size=None,
    method __read_data__ (line 315) | def __read_data__(self):
    method __getitem__ (line 370) | def __getitem__(self, index):
    method __len__ (line 386) | def __len__(self):
    method inverse_transform (line 389) | def inverse_transform(self, data):

FILE: ts_forecasting_methods/SupervisedBaselines/exp/exp_basic.py
  class Exp_Basic (line 6) | class Exp_Basic(object):
    method __init__ (line 7) | def __init__(self, args):
    method _build_model (line 12) | def _build_model(self):
    method _acquire_device (line 16) | def _acquire_device(self):
    method _get_data (line 27) | def _get_data(self):
    method vali (line 30) | def vali(self):
    method train (line 33) | def train(self):
    method test (line 36) | def test(self):

FILE: ts_forecasting_methods/SupervisedBaselines/exp/exp_informer.py
  class Exp_Informer (line 22) | class Exp_Informer(Exp_Basic):
    method __init__ (line 23) | def __init__(self, args):
    method _build_model (line 26) | def _build_model(self):
    method _select_optimizer (line 61) | def _select_optimizer(self):
    method _select_optimizer_p (line 65) | def _select_optimizer_p(self):
    method _select_criterion (line 70) | def _select_criterion(self):
    method vali (line 74) | def vali(self, vali_loader, scaler,criterion):
    method train (line 112) | def train(self, setting):
    method test (line 210) | def test(self, setting):
    method predict (line 280) | def predict(self, setting, load=False):

FILE: ts_forecasting_methods/SupervisedBaselines/exp/exp_main.py
  class Exp_Main (line 24) | class Exp_Main(Exp_Basic):
    method __init__ (line 25) | def __init__(self, args):
    method _build_model (line 28) | def _build_model(self):
    method _get_data (line 44) | def _get_data(self, flag):
    method _select_optimizer (line 48) | def _select_optimizer(self):
    method _select_criterion (line 52) | def _select_criterion(self):
    method vali (line 56) | def vali(self, vali_data, vali_loader, criterion):
    method train (line 96) | def train(self, setting):
    method test (line 195) | def test(self, setting, test=0):
    method predict (line 277) | def predict(self, setting, load=False):

FILE: ts_forecasting_methods/SupervisedBaselines/layers/AutoCorrelation.py
  class AutoCorrelation (line 11) | class AutoCorrelation(nn.Module):
    method __init__ (line 18) | def __init__(self, mask_flag=True, factor=1, scale=None, attention_dro...
    method time_delay_agg_training (line 26) | def time_delay_agg_training(self, values, corr):
    method time_delay_agg_inference (line 50) | def time_delay_agg_inference(self, values, corr):
    method time_delay_agg_full (line 77) | def time_delay_agg_full(self, values, corr):
    method forward (line 101) | def forward(self, queries, keys, values, attn_mask):
  class AutoCorrelationLayer (line 130) | class AutoCorrelationLayer(nn.Module):
    method __init__ (line 131) | def __init__(self, correlation, d_model, n_heads, d_keys=None,
    method forward (line 145) | def forward(self, queries, keys, values, attn_mask):

FILE: ts_forecasting_methods/SupervisedBaselines/layers/Autoformer_EncDec.py
  class my_Layernorm (line 6) | class my_Layernorm(nn.Module):
    method __init__ (line 10) | def __init__(self, channels):
    method forward (line 14) | def forward(self, x):
  class moving_avg (line 20) | class moving_avg(nn.Module):
    method __init__ (line 24) | def __init__(self, kernel_size, stride):
    method forward (line 29) | def forward(self, x):
  class series_decomp (line 39) | class series_decomp(nn.Module):
    method __init__ (line 43) | def __init__(self, kernel_size):
    method forward (line 47) | def forward(self, x):
  class EncoderLayer (line 53) | class EncoderLayer(nn.Module):
    method __init__ (line 57) | def __init__(self, attention, d_model, d_ff=None, moving_avg=25, dropo...
    method forward (line 68) | def forward(self, x, attn_mask=None):
  class Encoder (line 82) | class Encoder(nn.Module):
    method __init__ (line 86) | def __init__(self, attn_layers, conv_layers=None, norm_layer=None):
    method forward (line 92) | def forward(self, x, attn_mask=None):
  class DecoderLayer (line 112) | class DecoderLayer(nn.Module):
    method __init__ (line 116) | def __init__(self, self_attention, cross_attention, d_model, c_out, d_...
    method forward (line 132) | def forward(self, x, cross, x_mask=None, cross_mask=None):
  class Decoder (line 153) | class Decoder(nn.Module):
    method __init__ (line 157) | def __init__(self, layers, norm_layer=None, projection=None):
    method forward (line 163) | def forward(self, x, cross, x_mask=None, cross_mask=None, trend=None):

FILE: ts_forecasting_methods/SupervisedBaselines/layers/Embed.py
  class PositionalEmbedding (line 8) | class PositionalEmbedding(nn.Module):
    method __init__ (line 9) | def __init__(self, d_model, max_len=5000):
    method forward (line 24) | def forward(self, x):
  class TokenEmbedding (line 28) | class TokenEmbedding(nn.Module):
    method __init__ (line 29) | def __init__(self, c_in, d_model):
    method forward (line 38) | def forward(self, x):
  class FixedEmbedding (line 43) | class FixedEmbedding(nn.Module):
    method __init__ (line 44) | def __init__(self, c_in, d_model):
    method forward (line 59) | def forward(self, x):
  class TemporalEmbedding (line 63) | class TemporalEmbedding(nn.Module):
    method __init__ (line 64) | def __init__(self, d_model, embed_type='fixed', freq='h'):
    method forward (line 81) | def forward(self, x):
  class TimeFeatureEmbedding (line 93) | class TimeFeatureEmbedding(nn.Module):
    method __init__ (line 94) | def __init__(self, d_model, embed_type='timeF', freq='h'):
    method forward (line 101) | def forward(self, x):
  class DataEmbedding (line 105) | class DataEmbedding(nn.Module):
    method __init__ (line 106) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 116) | def forward(self, x, x_mark):
  class DataEmbedding_wo_pos (line 121) | class DataEmbedding_wo_pos(nn.Module):
    method __init__ (line 122) | def __init__(self, c_in, d_model, embed_type='fixed', freq='h', dropou...
    method forward (line 132) | def forward(self, x, x_mark):

FILE: ts_forecasting_methods/SupervisedBaselines/layers/SelfAttention_Family.py
  class FullAttention (line 15) | class FullAttention(nn.Module):
    method __init__ (line 16) | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dro...
    method forward (line 23) | def forward(self, queries, keys, values, attn_mask):
  class ProbAttention (line 45) | class ProbAttention(nn.Module):
    method __init__ (line 46) | def __init__(self, mask_flag=True, factor=5, scale=None, attention_dro...
    method _prob_QK (line 54) | def _prob_QK(self, Q, K, sample_k, n_top):  # n_top: c*ln(L_q)
    method _get_initial_context (line 77) | def _get_initial_context(self, V, L_Q):
    method _update_context (line 88) | def _update_context(self, context_in, V, scores, index, L_Q, attn_mask):
    method forward (line 107) | def forward(self, queries, keys, values, attn_mask):
  class AttentionLayer (line 135) | class AttentionLayer(nn.Module):
    method __init__ (line 136) | def __init__(self, attention, d_model, n_heads, d_keys=None,
    method forward (line 150) | def forward(self, queries, keys, values, attn_mask):
  class ReformerLayer (line 170) | class ReformerLayer(nn.Module):
    method __init__ (line 171) | def __init__(self, attention, d_model, n_heads, d_keys=None,
    method fit_length (line 183) | def fit_length(self, queries):
    method forward (line 193) | def forward(self, queries, keys, values, attn_mask):

FILE: ts_forecasting_methods/SupervisedBaselines/layers/Transformer_EncDec.py
  class ConvLayer (line 6) | class ConvLayer(nn.Module):
    method __init__ (line 7) | def __init__(self, c_in):
    method forward (line 18) | def forward(self, x):
  class EncoderLayer (line 27) | class EncoderLayer(nn.Module):
    method __init__ (line 28) | def __init__(self, attention, d_model, d_ff=None, dropout=0.1, activat...
    method forward (line 39) | def forward(self, x, attn_mask=None):
  class Encoder (line 53) | class Encoder(nn.Module):
    method __init__ (line 54) | def __init__(self, attn_layers, conv_layers=None, norm_layer=None):
    method forward (line 60) | def forward(self, x, attn_mask=None):
  class DecoderLayer (line 81) | class DecoderLayer(nn.Module):
    method __init__ (line 82) | def __init__(self, self_attention, cross_attention, d_model, d_ff=None,
    method forward (line 96) | def forward(self, x, cross, x_mask=None, cross_mask=None):
  class Decoder (line 115) | class Decoder(nn.Module):
    method __init__ (line 116) | def __init__(self, layers, norm_layer=None, projection=None):
    method forward (line 122) | def forward(self, x, cross, x_mask=None, cross_mask=None):

FILE: ts_forecasting_methods/SupervisedBaselines/utils/masking.py
  class TriangularCausalMask (line 4) | class TriangularCausalMask():
    method __init__ (line 5) | def __init__(self, B, L, device="cpu"):
    method mask (line 11) | def mask(self):
  class ProbMask (line 15) | class ProbMask():
    method __init__ (line 16) | def __init__(self, B, H, L, index, scores, device="cpu"):
    method mask (line 25) | def mask(self):

FILE: ts_forecasting_methods/SupervisedBaselines/utils/metrics.py
  function RSE (line 4) | def RSE(pred, true):
  function CORR (line 8) | def CORR(pred, true):
  function MAE (line 14) | def MAE(pred, true):
  function MSE (line 18) | def MSE(pred, true):
  function RMSE (line 22) | def RMSE(pred, true):
  function MAPE (line 26) | def MAPE(pred, true):
  function MSPE (line 30) | def MSPE(pred, true):
  function metric (line 34) | def metric(pred, true):

FILE: ts_forecasting_methods/SupervisedBaselines/utils/timefeatures.py
  class TimeFeature (line 9) | class TimeFeature:
    method __init__ (line 10) | def __init__(self):
    method __call__ (line 13) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
    method __repr__ (line 16) | def __repr__(self):
  class SecondOfMinute (line 20) | class SecondOfMinute(TimeFeature):
    method __call__ (line 23) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class MinuteOfHour (line 27) | class MinuteOfHour(TimeFeature):
    method __call__ (line 30) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class HourOfDay (line 34) | class HourOfDay(TimeFeature):
    method __call__ (line 37) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class DayOfWeek (line 41) | class DayOfWeek(TimeFeature):
    method __call__ (line 44) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class DayOfMonth (line 48) | class DayOfMonth(TimeFeature):
    method __call__ (line 51) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class DayOfYear (line 55) | class DayOfYear(TimeFeature):
    method __call__ (line 58) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class MonthOfYear (line 62) | class MonthOfYear(TimeFeature):
    method __call__ (line 65) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class WeekOfYear (line 69) | class WeekOfYear(TimeFeature):
    method __call__ (line 72) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  function time_features_from_frequency_str (line 76) | def time_features_from_frequency_str(freq_str: str) -> List[TimeFeature]:
  function time_features (line 133) | def time_features(dates, freq='h'):

FILE: ts_forecasting_methods/SupervisedBaselines/utils/tools.py
  function adjust_learning_rate (line 8) | def adjust_learning_rate(optimizer, epoch, args):
  class EarlyStopping (line 24) | class EarlyStopping:
    method __init__ (line 25) | def __init__(self, patience=7, verbose=False, delta=0):
    method __call__ (line 34) | def __call__(self, val_loss, model, path):
    method save_checkpoint (line 49) | def save_checkpoint(self, val_loss, model, path):
  class dotdict (line 56) | class dotdict(dict):
  class StandardScaler (line 63) | class StandardScaler():
    method __init__ (line 64) | def __init__(self, mean, std):
    method transform (line 68) | def transform(self, data):
    method inverse_transform (line 71) | def inverse_transform(self, data):
  function visual (line 75) | def visual(true, preds=None, name='./pic/test.pdf'):

FILE: ts_forecasting_methods/ts2vec/data_provider/data_factory.py
  function data_provider (line 105) | def data_provider(args, flag, drop_last_test=True, train_all=False):

FILE: ts_forecasting_methods/ts2vec/data_provider/data_loader.py
  class TimeFeature (line 27) | class TimeFeature:
    method __init__ (line 28) | def __init__(self):
    method __call__ (line 31) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
    method __repr__ (line 34) | def __repr__(self):
  class SecondOfMinute (line 38) | class SecondOfMinute(TimeFeature):
    method __call__ (line 41) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class MinuteOfHour (line 45) | class MinuteOfHour(TimeFeature):
    method __call__ (line 48) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class HourOfDay (line 52) | class HourOfDay(TimeFeature):
    method __call__ (line 55) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class DayOfWeek (line 59) | class DayOfWeek(TimeFeature):
    method __call__ (line 62) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class DayOfMonth (line 66) | class DayOfMonth(TimeFeature):
    method __call__ (line 69) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class DayOfYear (line 73) | class DayOfYear(TimeFeature):
    method __call__ (line 76) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class MonthOfYear (line 80) | class MonthOfYear(TimeFeature):
    method __call__ (line 83) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  class WeekOfYear (line 87) | class WeekOfYear(TimeFeature):
    method __call__ (line 90) | def __call__(self, index: pd.DatetimeIndex) -> np.ndarray:
  function time_features_from_frequency_str (line 94) | def time_features_from_frequency_str(freq_str: str) -> List[TimeFeature]:
  function time_features (line 152) | def time_features(dates, freq='h'):
  class Dataset_ETT_hour (line 157) | class Dataset_ETT_hour(Dataset):
    method __init__ (line 158) | def __init__(self, root_path, flag='train', size=None,
    method __read_data__ (line 193) | def __read_data__(self):
    method __getitem__ (line 235) | def __getitem__(self, index):
    method __len__ (line 249) | def __len__(self):
    method inverse_transform (line 252) | def inverse_transform(self, data):
  class Dataset_ETT_minute (line 256) | class Dataset_ETT_minute(Dataset):
    method __init__ (line 257) | def __init__(self, root_path, flag='train', size=None,
    method __read_data__ (line 290) | def __read_data__(self):
    method __getitem__ (line 333) | def __getitem__(self, index):
    method __len__ (line 347) | def __len__(self):
    method inverse_transform (line 350) | def inverse_transform(self, data):
  class Dataset_Custom (line 354) | class Dataset_Custom(Dataset):
    method __init__ (line 355) | def __init__(self, root_path, flag='train', size=None,
    method __read_data__ (line 388) | def __read_data__(self):
    method __getitem__ (line 441) | def __getitem__(self, index):
    method __len__ (line 455) | def __len__(self):
    method inverse_transform (line 458) | def inverse_transform(self, data):
  class Dataset_Pred (line 462) | class Dataset_Pred(Dataset):
    method __init__ (line 463) | def __init__(self, root_path, flag='pred', size=None,
    method __read_data__ (line 491) | def __read_data__(self):
    method __getitem__ (line 546) | def __getitem__(self, index):
    method __len__ (line 562) | def __len__(self):
    method inverse_transform (line 565) | def inverse_transform(self, data):
  class Dataset_TSF (line 569) | class Dataset_TSF(Dataset):
    method __init__ (line 570) | def __init__(self, root_path, flag='train', size=None,
    method __read_data__ (line 591) | def __read_data__(self):
    method __getitem__ (line 633) | def __getitem__(self, index):
    method __len__ (line 664) | def __len__(self):

FILE: ts_forecasting_methods/ts2vec/data_provider/m4.py
  function url_file_name (line 35) | def url_file_name(url: str) -> str:
  function download (line 45) | def download(url: str, file_path: str) -> None:
  class M4Dataset (line 74) | class M4Dataset:
    method load (line 82) | def load(training: bool = True, dataset_file: str = '../dataset/m4') -...
  class M4Meta (line 102) | class M4Meta:
  function load_m4_info (line 132) | def load_m4_info() -> pd.DataFrame:

FILE: ts_forecasting_methods/ts2vec/data_provider/metrics.py
  function RSE (line 4) | def RSE(pred, true):
  function CORR (line 8) | def CORR(pred, true):
  function MAE (line 14) | def MAE(pred, true):
  function MSE (line 18) | def MSE(pred, true):
  function RMSE (line 22) | def RMSE(pred, true):
  function MAPE (line 26) | def MAPE(pred, true):
  function MSPE (line 30) | def MSPE(pred, true):
  function SMAPE (line 33) | def SMAPE(pred, true):
  function ND (line 37) | def ND(pred, true):
  function metric (line 40) | def metric(pred, true):

FILE: ts_forecasting_methods/ts2vec/data_provider/tools.py
  function adjust_learning_rate (line 16) | def adjust_learning_rate(optimizer, epoch, args):
  class EarlyStopping (line 44) | class EarlyStopping:
    method __init__ (line 45) | def __init__(self, patience=7, verbose=False, delta=0):
    method __call__ (line 54) | def __call__(self, val_loss, model, path):
    method save_checkpoint (line 69) | def save_checkpoint(self, val_loss, model, path):
  class dotdict (line 76) | class dotdict(dict):
  class StandardScaler (line 83) | class StandardScaler():
    method __init__ (line 84) | def __init__(self, mean, std):
    method transform (line 88) | def transform(self, data):
    method inverse_transform (line 91) | def inverse_transform(self, data):
  function visual (line 95) | def visual(true, preds=None, name='./pic/test.pdf'):
  function convert_tsf_to_dataframe (line 107) | def convert_tsf_to_dataframe(
  function vali (line 252) | def vali(model, vali_data, vali_loader, criterion, args, device, itr):
  function MASE (line 288) | def MASE(x, freq, pred, true):
  function test (line 293) | def test(model, test_data, test_loader, args, device, itr):

FILE: ts_forecasting_methods/ts2vec/data_provider/uea.py
  function collate_fn (line 7) | def collate_fn(data, max_len=None):
  function padding_mask (line 45) | def padding_mask(lengths, max_len=None):
  class Normalizer (line 58) | class Normalizer(object):
    method __init__ (line 63) | def __init__(self, norm_type='standardization', mean=None, std=None, m...
    method normalize (line 78) | def normalize(self, df):
  function interpolate_missing (line 110) | def interpolate_missing(y):
  function subsample (line 119) | def subsample(y, limit=256, factor=2):

FILE: ts_forecasting_methods/ts2vec/datautils.py
  function load_UCR (line 12) | def load_UCR(dataset):
  function load_UEA (line 79) | def load_UEA(dataset):
  function load_forecast_npy (line 108) | def load_forecast_npy(name, univar=False):
  function _get_time_features (line 125) | def _get_time_features(dt):
  function load_forecast_csv (line 137) | def load_forecast_csv(name, univar=False):
  function load_anomaly (line 195) | def load_anomaly(name):
  function gen_ano_train_data (line 202) | def gen_ano_train_data(all_train_data):

FILE: ts_forecasting_methods/ts2vec/models/dilated_conv.py
  class SamePadConv (line 6) | class SamePadConv(nn.Module):
    method __init__ (line 7) | def __init__(self, in_channels, out_channels, kernel_size, dilation=1,...
    method forward (line 19) | def forward(self, x):
  class ConvBlock (line 25) | class ConvBlock(nn.Module):
    method __init__ (line 26) | def __init__(self, in_channels, out_channels, kernel_size, dilation, f...
    method forward (line 32) | def forward(self, x):
  class DilatedConvEncoder (line 40) | class DilatedConvEncoder(nn.Module):
    method __init__ (line 41) | def __init__(self, in_channels, channels, kernel_size):
    method forward (line 54) | def forward(self, x):

FILE: ts_forecasting_methods/ts2vec/models/encoder.py
  function generate_continuous_mask (line 7) | def generate_continuous_mask(B, T, n=5, l=0.1):
  function generate_binomial_mask (line 23) | def generate_binomial_mask(B, T, p=0.5):
  class TSEncoder (line 26) | class TSEncoder(nn.Module):
    method __init__ (line 27) | def __init__(self, input_dims, output_dims, hidden_dims=64, depth=10, ...
    method forward (line 41) | def forward(self, x, mask=None):  # x: B x T x input_dims

FILE: ts_forecasting_methods/ts2vec/models/losses.py
  function hierarchical_contrastive_loss (line 5) | def hierarchical_contrastive_loss(z1, z2, alpha=0.5, temporal_unit=0):
  function instance_contrastive_loss (line 23) | def instance_contrastive_loss(z1, z2):
  function temporal_contrastive_loss (line 38) | def temporal_contrastive_loss(z1, z2):

FILE: ts_forecasting_methods/ts2vec/tasks/_eval_protocols.py
  function fit_svm (line 10) | def fit_svm(features, y, MAX_SAMPLES=10000):
  function fit_lr (line 52) | def fit_lr(features, y, MAX_SAMPLES=100000):
  function fit_knn (line 73) | def fit_knn(features, y):
  function fit_ridge (line 81) | def fit_ridge(train_features, train_y, valid_features, valid_y, MAX_SAMP...

FILE: ts_forecasting_methods/ts2vec/tasks/anomaly_detection.py
  function get_range_proba (line 7) | def get_range_proba(predict, label, delay=7):
  function reconstruct_label (line 33) | def reconstruct_label(timestamp, label):
  function eval_ad_result (line 51) | def eval_ad_result(test_pred_list, test_labels_list, test_timestamps_lis...
  function np_shift (line 70) | def np_shift(arr, num, fill_value=np.nan):
  function eval_anomaly_detection (line 83) | def eval_anomaly_detection(model, all_train_data, all_train_labels, all_...
  function eval_anomaly_detection_coldstart (line 152) | def eval_anomaly_detection_coldstart(model, all_train_data, all_train_la...

FILE: ts_forecasting_methods/ts2vec/tasks/classification.py
  function eval_classification (line 6) | def eval_classification(model, train_data, train_labels, test_data, test...

FILE: ts_forecasting_methods/ts2vec/tasks/forecasting.py
  function generate_pred_samples (line 5) | def generate_pred_samples(features, data, pred_len, drop=0):
  function cal_metrics (line 14) | def cal_metrics(pred, target):
  function eval_forecasting (line 20) | def eval_forecasting(model, data, train_slice, valid_slice, test_slice, ...
  function eval_forecasting_new (line 99) | def eval_forecasting_new(model, train_data, valid_data, test_data, pred_...

FILE: ts_forecasting_methods/ts2vec/train.py
  function save_checkpoint_callback (line 13) | def save_checkpoint_callback(

FILE: ts_forecasting_methods/ts2vec/ts2vec.py
  class TS2Vec (line 10) | class TS2Vec:
    method __init__ (line 13) | def __init__(
    method fit (line 60) | def fit(self, train_data, n_epochs=None, n_iters=None, verbose=False):
    method _eval_with_pooling (line 162) | def _eval_with_pooling(self, x, mask=None, slicing=None, encoding_wind...
    method encode (line 206) | def encode(self, data, mask=None, encoding_window=None, casual=False, ...
    method save (line 303) | def save(self, fn):
    method load (line 311) | def load(self, fn):

FILE: ts_forecasting_methods/ts2vec/utils.py
  function pkl_save (line 8) | def pkl_save(name, var):
  function pkl_load (line 12) | def pkl_load(name):
  function torch_pad_nan (line 16) | def torch_pad_nan(arr, left=0, right=0, dim=0):
  function pad_nan_to_target (line 27) | def pad_nan_to_target(array, target_length, axis=0, both_side=False):
  function split_with_nan (line 39) | def split_with_nan(x, sections, axis=0):
  function take_per_row (line 47) | def take_per_row(A, indx, num_elem):
  function centerize_vary_length_series (line 51) | def centerize_vary_length_series(x):
  function data_dropout (line 60) | def data_dropout(arr, p):
  function name_with_datetime (line 73) | def name_with_datetime(prefix='default'):
  function init_dl_program (line 77) | def init_dl_program(