diff --git a/.gitignore b/.gitignore
index 104809f88..dc57879be 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,9 +3,16 @@ __pycache__/
*.py[cod]
*$py.class
+test_results/test_iTransformer_custom_MS_ft15_sl1_ll3_pl512_dm8_nh8_el8_dl1024_df1_fctimeF_ebTrue_dttest_projection_0
+
+results/test_iTransformer_custom_MS_ft15_sl1_ll3_pl512_dm8_nh8_el8_dl1024_df1_fctimeF_ebTrue_dttest_projection_0
+result_long_term_forecast.txt
# C extensions
*.so
-
+input/test/data.csv
+input/test/scaler.pkl
+input/train/data.csv
+input/train/scaler.pkl
*/.DS_Store
# Distribution / packaging
@@ -128,4 +135,4 @@ venv.bak/
dmypy.json
# Pyre type checker
-.pyre/
\ No newline at end of file
+.pyre/
diff --git a/LICENSE b/LICENSE
index 6f6856e74..f4ad474ad 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,7 @@
MIT License
Copyright (c) 2022 THUML @ Tsinghua University
+Copyright (c) 2024 cloner174 @ Hamed Hajipour
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
diff --git a/checkpoints/DONOTREMOVE b/checkpoints/DONOTREMOVE
new file mode 100644
index 000000000..e69de29bb
diff --git a/data_provider/data_factory.py b/data_provider/data_factory.py
index 51a5fc87f..b55e7c4f5 100644
--- a/data_provider/data_factory.py
+++ b/data_provider/data_factory.py
@@ -16,39 +16,58 @@
def data_provider(args, flag):
Data = data_dict[args.data]
timeenc = 0 if args.embed != 'timeF' else 1
-
- if flag == 'test':
- shuffle_flag = False
- drop_last = True
- batch_size = 1 # bsz=1 for evaluation
- freq = args.freq
- elif flag == 'pred':
+ if flag == 'pred' :
shuffle_flag = False
drop_last = False
batch_size = 1
freq = args.freq
Data = Dataset_Pred
+ data_set = Data(
+ root_path=args.pred_root_path,
+ data_path=args.pred_data_path,
+ flag=flag,
+ size=[args.seq_len, args.label_len, args.pred_len],
+ features=args.features,
+ target=args.target,
+ timeenc=timeenc,
+ freq=freq,
+ kind_of_scaler=args.kind_of_scaler if hasattr(args, 'kind_of_scaler') else 'standard',
+ name_of_col_with_date = args.name_of_col_with_date if hasattr(args, 'name_of_col_with_date') else 'date',
+ scale = args.scale if hasattr(args, 'scale') else True,
+ max_use_of_row = args.max_use_of_row if hasattr(args, 'max_use_of_row') else 'No Lim',
+ )
+ print(flag, len(data_set))
else:
- shuffle_flag = True
- drop_last = True
- batch_size = args.batch_size # bsz for train and valid
- freq = args.freq
-
- data_set = Data(
- root_path=args.root_path,
- data_path=args.data_path,
- flag=flag,
- size=[args.seq_len, args.label_len, args.pred_len],
- features=args.features,
- target=args.target,
- timeenc=timeenc,
- freq=freq,
- )
- print(flag, len(data_set))
+ if flag == 'test':
+ shuffle_flag = False
+ drop_last = True
+ batch_size = 1 # bsz=1 for evaluation
+ freq = args.freq
+ else:
+ shuffle_flag = True
+ drop_last = True
+ batch_size = args.batch_size # bsz for train and valid
+ freq = args.freq
+ data_set = Data(
+ root_path=args.root_path,
+ data_path=args.data_path,
+ flag=flag,
+ size=[args.seq_len, args.label_len, args.pred_len],
+ features=args.features,
+ target=args.target,
+ timeenc=timeenc,
+ freq=freq,
+ test_size = args.test_size if hasattr(args, 'test_size') else 0.2,
+ kind_of_scaler= args.kind_of_scaler if hasattr(args, 'kind_of_scaler') else 'standard',
+ name_of_col_with_date = args.name_of_col_with_date if hasattr(args, 'name_of_col_with_date') else 'date',
+ scale = args.scale if hasattr(args, 'scale') else True,
+ )
+ print(flag, len(data_set))
data_loader = DataLoader(
data_set,
batch_size=batch_size,
shuffle=shuffle_flag,
num_workers=args.num_workers,
drop_last=drop_last)
+
return data_set, data_loader
diff --git a/data_provider/data_loader.py b/data_provider/data_loader.py
index c86471da7..0885d6400 100644
--- a/data_provider/data_loader.py
+++ b/data_provider/data_loader.py
@@ -1,11 +1,13 @@
import os
import numpy as np
import pandas as pd
+import joblib
import torch
from torch.utils.data import Dataset, DataLoader
-from sklearn.preprocessing import StandardScaler
+from sklearn.preprocessing import StandardScaler, MinMaxScaler
from utils.timefeatures import time_features
import warnings
+import time
warnings.filterwarnings('ignore')
@@ -189,15 +191,25 @@ def inverse_transform(self, data):
class Dataset_Custom(Dataset):
- def __init__(self, root_path, flag='train', size=None,
- features='S', data_path='ETTh1.csv',
- target='OT', scale=True, timeenc=0, freq='h'):
+ def __init__(self,
+ root_path,
+ flag='train',
+ size=None,
+ features='MS',
+ data_path='data.csv',
+ target='Close',
+ scale=True,
+ timeenc=0,
+ freq='b',
+ test_size = 0.2,
+ kind_of_scaler = None,
+ name_of_col_with_date = None):
# size [seq_len, label_len, pred_len]
# info
if size == None:
- self.seq_len = 24 * 4 * 4
- self.label_len = 24 * 4
- self.pred_len = 24 * 4
+ self.seq_len = 1 * 5 * 3 # Three week - work week ! only 5 days are alive!
+ self.label_len = 1 * 1 # Predict one day ahead
+ self.pred_len = 1 * 1 # Just for one time!
else:
self.seq_len = size[0]
self.label_len = size[1]
@@ -212,25 +224,40 @@ def __init__(self, root_path, flag='train', size=None,
self.scale = scale
self.timeenc = timeenc
self.freq = freq
-
+ self.test_size = test_size if test_size is not None else 0.2
+ self.train_size = 0.90 - test_size
+ self.kind_of_scaler = kind_of_scaler if kind_of_scaler is not None else 'Standard'
+ self.name_of_col_with_date = name_of_col_with_date if name_of_col_with_date is not None else 'date'
self.root_path = root_path
self.data_path = data_path
+
+ self.scaler_path = os.path.join('./input', 'Scalers')
+ os.makedirs(self.scaler_path, exist_ok=True)
+
self.__read_data__()
def __read_data__(self):
- self.scaler = StandardScaler()
- df_raw = pd.read_csv(os.path.join(self.root_path,
- self.data_path))
-
+
+ if self.root_path == 'None':
+ df_raw = pd.read_csv(self.data_path)
+ else:
+ df_raw = pd.read_csv(os.path.join(self.root_path,
+ self.data_path))
+
'''
df_raw.columns: ['date', ...(other features), target feature]
'''
+
cols = list(df_raw.columns)
cols.remove(self.target)
- cols.remove('date')
- df_raw = df_raw[['date'] + cols + [self.target]]
- num_train = int(len(df_raw) * 0.7)
- num_test = int(len(df_raw) * 0.2)
+ cols.remove(self.name_of_col_with_date)
+ df_raw = df_raw[[self.name_of_col_with_date] + cols + [self.target]]
+ cols.insert(0, 'date')
+ cols.append(self.target)
+ df_raw = df_raw.set_axis(cols, axis=1)
+
+ num_train = int(len(df_raw) * self.train_size)
+ num_test = int(len(df_raw) * self.test_size)
num_vali = len(df_raw) - num_train - num_test
border1s = [0, num_train - self.seq_len, len(df_raw) - num_test - self.seq_len]
border2s = [num_train, num_train + num_vali, len(df_raw)]
@@ -242,14 +269,52 @@ def __read_data__(self):
df_data = df_raw[cols_data]
elif self.features == 'S':
df_data = df_raw[[self.target]]
-
+
+ file_path = self.scaler_path + 'scaler.pkl'
+ if os.path.exists(file_path):
+ base, ext = os.path.splitext(file_path)
+ timestamp = time.strftime("%Y%m%d_%H%M%S")
+ file_path = f"{base}_{timestamp}{ext}"
+ self.scaler_path = file_path
+
if self.scale:
- train_data = df_data[border1s[0]:border2s[0]]
- self.scaler.fit(train_data.values)
- data = self.scaler.transform(df_data.values)
+ if self.features == 'S' or self.features == 'MS':
+ col_scaled = []
+ for col in df_data.columns:
+ col_data = df_data[[col]].values
+ if self.kind_of_scaler == 'MinMax':
+ if col == self.target:
+ self.scaler = MinMaxScaler()
+ else:
+ scaler = MinMaxScaler()
+ else:
+ if col == self.target:
+ self.scaler = StandardScaler()
+ else:
+ scaler = StandardScaler()
+ if col == self.target:
+ self.scaler.fit(col_data[border1s[0]:border2s[0]])
+ joblib.dump(self.scaler, self.scaler_path)
+ col_temp = self.scaler.transform(col_data)
+ else:
+ scaler.fit(col_data[border1s[0]:border2s[0]])
+ col_temp = scaler.transform(col_data)
+ col_scaled.append(col_temp)
+ if len(col_scaled) == 1:
+ data = col_scaled[0]
+ else:
+ data = np.concatenate(col_scaled, axis = 1)
+ else:
+ if self.kind_of_scaler == 'MinMax':
+ self.scaler = MinMaxScaler()
+ else:
+ self.scaler = StandardScaler()
+ train_data = df_data[border1s[0]:border2s[0]]
+ self.scaler.fit(train_data.values)
+ data = self.scaler.transform(df_data.values)
else:
data = df_data.values
-
+
df_stamp = df_raw[['date']][border1:border2]
df_stamp['date'] = pd.to_datetime(df_stamp.date)
if self.timeenc == 0:
@@ -257,7 +322,7 @@ def __read_data__(self):
df_stamp['day'] = df_stamp.date.apply(lambda row: row.day, 1)
df_stamp['weekday'] = df_stamp.date.apply(lambda row: row.weekday(), 1)
df_stamp['hour'] = df_stamp.date.apply(lambda row: row.hour, 1)
- data_stamp = df_stamp.drop(['date'], 1).values
+ data_stamp = df_stamp.drop(['date'], axis = 1).values
elif self.timeenc == 1:
data_stamp = time_features(pd.to_datetime(df_stamp['date'].values), freq=self.freq)
data_stamp = data_stamp.transpose(1, 0)
@@ -288,8 +353,8 @@ def inverse_transform(self, data):
class Dataset_PEMS(Dataset):
def __init__(self, root_path, flag='train', size=None,
- features='S', data_path='ETTh1.csv',
- target='OT', scale=True, timeenc=0, freq='h'):
+ features='S', data_path='ETTh1.csv',
+ target='OT', scale=True, timeenc=0, freq='h'):
# size [seq_len, label_len, pred_len]
# info
self.seq_len = size[0]
@@ -431,21 +496,26 @@ def inverse_transform(self, data):
class Dataset_Pred(Dataset):
def __init__(self, root_path, flag='pred', size=None,
- features='S', data_path='ETTh1.csv',
- target='OT', scale=True, inverse=False, timeenc=0, freq='15min', cols=None):
+ features='MS', data_path='data-pred.csv',
+ target='Close', scale=True, inverse=False, timeenc=0, freq='b', cols=None,
+ max_use_of_row = 'No Lim',#It also can be 'All Except a Week' or 'All Except 3 Days'
+ kind_of_scaler = None,
+ name_of_col_with_date = None):
# size [seq_len, label_len, pred_len]
# info
if size == None:
- self.seq_len = 24 * 4 * 4
- self.label_len = 24 * 4
- self.pred_len = 24 * 4
+ self.seq_len = 1 * 5 * 6
+ self.label_len = 1 * 1
+ self.pred_len = 1 * 3
else:
self.seq_len = size[0]
self.label_len = size[1]
self.pred_len = size[2]
# init
assert flag in ['pred']
-
+
+ self.kind_of_scaler = kind_of_scaler if kind_of_scaler is not None else 'Standard'
+ self.name_of_col_with_date = name_of_col_with_date if name_of_col_with_date is not None else 'date'
self.features = features
self.target = target
self.scale = scale
@@ -455,12 +525,22 @@ def __init__(self, root_path, flag='pred', size=None,
self.cols = cols
self.root_path = root_path
self.data_path = data_path
+ max_use_of_row = max_use_of_row if max_use_of_row is not None else 'No Lim'
+ self.max_use_of_row = 7 if max_use_of_row.lower() == 'all except a week' else 3 if max_use_of_row.lower() == 'all except 3 days' else 0
+
+ self.scaler_path = os.path.join('./input', 'Scalers')
+ os.makedirs(self.scaler_path, exist_ok=True)
+
self.__read_data__()
-
+
+
def __read_data__(self):
self.scaler = StandardScaler()
- df_raw = pd.read_csv(os.path.join(self.root_path,
- self.data_path))
+ if self.root_path == 'None':
+ df_raw = pd.read_csv(self.data_path)
+ else:
+ df_raw = pd.read_csv(os.path.join(self.root_path,
+ self.data_path))
'''
df_raw.columns: ['date', ...(other features), target feature]
'''
@@ -470,27 +550,70 @@ def __read_data__(self):
else:
cols = list(df_raw.columns)
cols.remove(self.target)
- cols.remove('date')
- df_raw = df_raw[['date'] + cols + [self.target]]
- border1 = len(df_raw) - self.seq_len
- border2 = len(df_raw)
-
+ cols.remove(self.name_of_col_with_date)
+ df_raw = df_raw[[self.name_of_col_with_date] + cols + [self.target]]
+ cols.insert(0, 'date')
+ cols.append(self.target)
+ df_raw = df_raw.set_axis(cols, axis=1)
+
+ border1 = len(df_raw) - self.max_use_of_row - self.seq_len
+ border2 = len(df_raw) - self.max_use_of_row
+
if self.features == 'M' or self.features == 'MS':
cols_data = df_raw.columns[1:]
df_data = df_raw[cols_data]
elif self.features == 'S':
df_data = df_raw[[self.target]]
-
+
+
+ file_path = self.scaler_path + 'scaler.pkl'
+ if os.path.exists(file_path):
+ base, ext = os.path.splitext(file_path)
+ timestamp = time.strftime("%Y%m%d_%H%M%S")
+ file_path = f"{base}_{timestamp}{ext}"
+ self.scaler_path = file_path
if self.scale:
- self.scaler.fit(df_data.values)
- data = self.scaler.transform(df_data.values)
+ if self.features == 'S' or self.features == 'MS':
+ col_scaled = []
+ for col in df_data.columns:
+ col_data = df_data[[col]].values
+ if self.kind_of_scaler == 'MinMax':
+ if col == self.target:
+ self.scaler = MinMaxScaler()
+ else:
+ scaler = MinMaxScaler()
+ else:
+ if col == self.target:
+ self.scaler = StandardScaler()
+ else:
+ scaler = StandardScaler()
+ if col == self.target:
+ self.scaler.fit(col_data)
+ joblib.dump(self.scaler, self.scaler_path)
+ col_temp = self.scaler.transform(col_data)
+ else:
+ scaler.fit(col_data)
+ col_temp = scaler.transform(col_data)
+ col_scaled.append(col_temp)
+ if len(col_scaled) == 1:
+ data = col_scaled[0]
+ else:
+ data = np.concatenate(col_scaled, axis = 1)
+ else:
+ if self.kind_of_scaler == 'MinMax':
+ self.scaler = MinMaxScaler()
+ else:
+ self.scaler = StandardScaler()
+
+ self.scaler.fit(df_data.values)
+ data = self.scaler.transform(df_data.values)
else:
data = df_data.values
-
+
tmp_stamp = df_raw[['date']][border1:border2]
tmp_stamp['date'] = pd.to_datetime(tmp_stamp.date)
pred_dates = pd.date_range(tmp_stamp.date.values[-1], periods=self.pred_len + 1, freq=self.freq)
-
+
df_stamp = pd.DataFrame(columns=['date'])
df_stamp.date = list(tmp_stamp.date.values) + list(pred_dates[1:])
if self.timeenc == 0:
@@ -500,24 +623,24 @@ def __read_data__(self):
df_stamp['hour'] = df_stamp.date.apply(lambda row: row.hour, 1)
df_stamp['minute'] = df_stamp.date.apply(lambda row: row.minute, 1)
df_stamp['minute'] = df_stamp.minute.map(lambda x: x // 15)
- data_stamp = df_stamp.drop(['date'], 1).values
+ data_stamp = df_stamp.drop(['date'], axis=1).values
elif self.timeenc == 1:
data_stamp = time_features(pd.to_datetime(df_stamp['date'].values), freq=self.freq)
data_stamp = data_stamp.transpose(1, 0)
-
+
self.data_x = data[border1:border2]
if self.inverse:
self.data_y = df_data.values[border1:border2]
else:
self.data_y = data[border1:border2]
self.data_stamp = data_stamp
-
+
def __getitem__(self, index):
s_begin = index
s_end = s_begin + self.seq_len
r_begin = s_end - self.label_len
r_end = r_begin + self.label_len + self.pred_len
-
+
seq_x = self.data_x[s_begin:s_end]
if self.inverse:
seq_y = self.data_x[r_begin:r_begin + self.label_len]
@@ -525,11 +648,11 @@ def __getitem__(self, index):
seq_y = self.data_y[r_begin:r_begin + self.label_len]
seq_x_mark = self.data_stamp[s_begin:s_end]
seq_y_mark = self.data_stamp[r_begin:r_end]
-
+
return seq_x, seq_y, seq_x_mark, seq_y_mark
-
+
def __len__(self):
return len(self.data_x) - self.seq_len + 1
-
+
def inverse_transform(self, data):
return self.scaler.inverse_transform(data)
diff --git a/experiments/after_train.py b/experiments/after_train.py
new file mode 100644
index 000000000..baa4cbc9b
--- /dev/null
+++ b/experiments/after_train.py
@@ -0,0 +1,202 @@
+import os
+import time
+import torch
+import tempfile
+import numpy as np
+import pandas as pd
+from datetime import timedelta
+from .exp_long_term_forecasting import Exp_Long_Term_Forecast
+from .exp_long_term_forecasting_partial import Exp_Long_Term_Forecast_Partial
+from .pre_train import SaveArgs, load_args
+
+
+def predict(args, model,
+ predict_root = None, predict_data = None,
+ days_to_predict = 1, retrain = False, new_data = None):#model= setting or actual model
+ """
+ Use Model To Predict Future Days!
+ Argumans:
+ args: Object | str, The models setup. Can be an Object of type DotDict class, or the path to saved file of it -> (args.json).
+ model: str|Object, Whether can be the setting or folder name of path to the 'checkpoint.pth' or the actual model object!
+ days_to_predict: int, How much days, should to be predicted!
+ predict_data: the name of predict data inside pred folder. if None, will use the current name in args.
+
+ retrain: bool, Optional. If True, and new_data is not None, It would change the setting and args to retrain the current model with new data.
+ new_data: str, The new data name inside the root path from args. If None, and retrain is True, It would use the current root path and data name in args to retrain model.
+ \Will Raise an Error, If no data is available/
+ """
+
+ if isinstance(args, str):
+ try:
+ arg = load_args(args)
+ except Exception as e:
+ raise AssertionError(f"Fail to read args.pkl reason -> {e}")
+ else:
+ try:
+ args_path = SaveArgs(args=args, path='', temporary=True)
+ args_path = args_path.path
+ arg = load_args(args_path)
+ os.unlink(args_path)
+ except Exception as e:
+ raise AssertionError(f"Fail to read args.pkl reason -> {e}")
+
+
+ if retrain and new_data is not None:
+ arg.data_path = new_data
+
+ if predict_data is not None:
+ if predict_root is not None:
+ arg.pred_root_path = predict_root
+ arg.pred_data_path = predict_data
+
+ if isinstance(model, Exp_Long_Term_Forecast) or isinstance(model, Exp_Long_Term_Forecast_Partial):
+ model.args = arg
+ exp = model
+ elif isinstance(model, str):
+ if arg.exp_name == 'partial_train':
+ Exp = Exp_Long_Term_Forecast_Partial
+ else:
+ Exp = Exp_Long_Term_Forecast
+ exp = Exp(arg)
+ try:
+ path = os.path.join(arg.checkpoints, model)
+ path = path + '/' + 'checkpoint.pth'
+ exp.model.load_state_dict(torch.load(path))
+ except Exception as e:
+ try:
+ exp.model.load_state_dict(torch.load(model))
+ except:
+ raise AssertionError(f" There was an Error loading your model with the provded path.Assumed path is {model} and Error was: {e}")
+ else:
+ raise TypeError(" The Model Object can be of type str(model checkpoint.pth path) or the actual model from experiments kind of models from this repo.")
+
+ if retrain:
+ timestamp = time.strftime("%Y%m%d_%H%M%S")
+ for ii in range(arg.itr):
+ setting = '{}_{}_{}_{}_ft{}_sl{}_ll{}_pl{}_dm{}_nh{}_el{}_dl{}_df{}_fc{}_eb{}_dt{}_{}_{}_{}'.format(
+ arg.model_id,
+ arg.model,
+ arg.data,
+ arg.features,
+ arg.seq_len,
+ arg.label_len,
+ arg.pred_len,
+ arg.d_model,
+ arg.n_heads,
+ arg.e_layers,
+ arg.d_layers,
+ arg.d_ff,
+ arg.factor,
+ arg.embed,
+ arg.distil,
+ arg.des,
+ arg.class_strategy, ii, timestamp)
+ print('>>>>>>>start training : {}>>>>>>>>>>>>>>>>>>>>>>>>>>'.format(setting))
+ exp.train(setting)
+
+ try:
+ df_temp = pd.read_csv(os.path.join(arg.pred_root_path, arg.pred_data_path))
+ except:
+ print(f'please inter the path to your prediction data in input arguman : predict_root and predict_data')
+ print('Where predict_root is the main folder contained your csv file and predict_data is name of the csv file with .csv at the end')
+ return 0
+ end_at_first = df_temp.shape[0] - 1
+ with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+ temp_path = f"{temp_file.name}.csv"
+ df_temp.to_csv(temp_path, index= False)
+ temp_file.seek(0)
+ del df_temp
+
+ folder_path = 'results/Prediction Results/'
+ os.makedirs(folder_path, exist_ok=True)
+ file_path = folder_path + 'prediction.csv'
+
+ if os.path.exists(file_path):
+ base, ext = os.path.splitext(file_path)
+ timestamp = time.strftime("%Y%m%d_%H%M%S")
+ file_path = f"{base}_{timestamp}{ext}"
+
+ for jj in range(days_to_predict):
+ if jj == 0:
+ pass
+ else:
+ arg.pred_root_path = 'None'
+ arg.pred_data_path = temp_path
+ exp.args = arg
+ pred_data, pred_loader = exp._get_data(flag='pred')
+ preds = []
+ exp.model.eval()
+ with torch.no_grad():
+ for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(pred_loader):
+ batch_x = batch_x.float().to(exp.device)
+ batch_y = batch_y.float().to(exp.device)
+ batch_x_mark = batch_x_mark.float().to(exp.device)
+ batch_y_mark = batch_y_mark.float().to(exp.device)
+ dec_inp = torch.zeros_like(batch_y[:, -exp.args.pred_len:, :]).float()
+ dec_inp = torch.cat([batch_y[:, :exp.args.label_len, :], dec_inp], dim=1).float().to(exp.device)
+ if exp.args.use_amp:
+ with torch.cuda.amp.autocast():
+ if exp.args.output_attention:
+ outputs = exp.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0]
+ else:
+ outputs = exp.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)
+ else:
+ if exp.args.output_attention:
+ outputs = exp.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0]
+ else:
+ outputs = exp.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)
+ outputs = outputs.detach().cpu().numpy()
+ if pred_data.scale:
+ shape = outputs.shape
+ outputs = pred_data.inverse_transform(outputs.squeeze(0)).reshape(shape)
+ preds.append(outputs)
+ preds = np.array(preds)
+ preds = preds.reshape(-1, preds.shape[-2], preds.shape[-1])
+ #preds = [round(any_) for any_ in preds.reshape(-1).tolist()]
+ preds = list(preds[0,0,:])
+ data = pd.read_csv(temp_path)
+ cols = list(data.columns)
+ date_name = arg.name_of_col_with_date if hasattr(arg, 'name_of_col_with_date') else 'date'
+ target = arg.target
+ data[date_name] = pd.to_datetime(data[date_name])
+ last_day = data.loc[data.shape[0]-1,date_name]
+ next_day = last_day + timedelta(days=1)
+ date_index = cols.index(date_name)
+ cols.pop(date_index)
+ temp = {}
+ for i in range(len(cols)):
+ col = cols[i]
+ if col == target :
+ if arg.features == 'MS' or arg.features == 'S' :
+ temp[col] = preds[-1]
+ else:
+ temp[col] = preds[i]
+ else:
+ if arg.features == 'S':
+ temp[col] = data.loc[end_at_first, col]
+ else:
+ temp[col] = preds[i]
+ temp = pd.DataFrame(temp, index=[data.shape[0]], dtype=int)
+ temp.insert(loc = date_index, column=date_name, value=next_day)
+ data = pd.concat([data, temp])
+ if days_to_predict > 1:
+ data.to_csv(temp_path, index = False)
+ #if use_predict_on_prediction and retrain:
+ # if arg.data == 'custom':
+ # arg.root_path = 'None'
+ # arg.data_path = temp_path
+ # exp.args = arg
+ # exp.train(setting)
+ # else:
+ # print("sorry can not be done")
+
+
+ if arg.features == 'S' or arg.features == 'MS':
+ data = pd.concat( [data.loc[end_at_first:,date_name], data.loc[end_at_first:,target]],axis=1)
+ else:
+ data = data.loc[end_at_first:,:]
+ data.to_csv(file_path, index = False)
+ os.unlink(temp_path)
+ print(f'''The Results of Prediction for The Next {days_to_predict} Days Are Now Stored in
+ {file_path}''')
+ return True
diff --git a/experiments/exp_long_term_forecasting.py b/experiments/exp_long_term_forecasting.py
index 1df9760a9..bb41d5a22 100644
--- a/experiments/exp_long_term_forecasting.py
+++ b/experiments/exp_long_term_forecasting.py
@@ -2,6 +2,7 @@
from experiments.exp_basic import Exp_Basic
from utils.tools import EarlyStopping, adjust_learning_rate, visual
from utils.metrics import metric
+from utils.criter import WeightedMeanAbsolutePercentageError, SymmetricMeanAbsolutePercentageError, RMSELoss,QuantileLoss, HuberLoss, PinballLoss
import torch
import torch.nn as nn
from torch import optim
@@ -9,48 +10,102 @@
import time
import warnings
import numpy as np
+from .pre_train import SaveArgs
warnings.filterwarnings('ignore')
-
+print("This is The enhanced version of Orginal code, Written in 2024")
+time.sleep(1)
class Exp_Long_Term_Forecast(Exp_Basic):
def __init__(self, args):
super(Exp_Long_Term_Forecast, self).__init__(args)
-
+ self.train_losses = []
+ self.test_losses = []
+ self.vali_losses = []
+ self.trues_during_vali = []
+ self.preds_during_vali = []
+ if args.is_training != 0:
+ try:
+ SaveArgs(args=args, path='input')
+ except:
+ print("Fail To Save The Args. Continue ..")
+ time.sleep(1)
+
+
def _build_model(self):
model = self.model_dict[self.args.model].Model(self.args).float()
-
if self.args.use_multi_gpu and self.args.use_gpu:
model = nn.DataParallel(model, device_ids=self.args.device_ids)
return model
-
+
def _get_data(self, flag):
data_set, data_loader = data_provider(self.args, flag)
return data_set, data_loader
-
+
def _select_optimizer(self):
- model_optim = optim.Adam(self.model.parameters(), lr=self.args.learning_rate)
+ if self.args.kind_of_optim == 'AdamW':
+ model_optim = optim.AdamW(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'SparseAdam':
+ model_optim = optim.SparseAdam(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'SGD':
+ model_optim = optim.SGD(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'RMSprop':
+ model_optim = optim.RMSprop(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'RAdam':
+ model_optim = optim.RAdam(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'NAdam':
+ model_optim = optim.NAdam(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'LBFGS':
+ model_optim = optim.LBFGS(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'Adamax':
+ model_optim = optim.Adamax(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'ASGD':
+ model_optim = optim.ASGD(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'Adadelta':
+ model_optim = optim.Adadelta(self.model.parameters(), lr=self.args.learning_rate)
+ elif self.args.kind_of_optim == 'Adagrad':
+ model_optim = optim.Adagrad(self.model.parameters(), lr=self.args.learning_rate)
+ else:
+ model_optim = optim.Adam(self.model.parameters(), lr=self.args.learning_rate)
+
return model_optim
def _select_criterion(self):
- criterion = nn.MSELoss()
+ if self.args.criter.lower() == 'wmape':
+ criterion = WeightedMeanAbsolutePercentageError()
+ elif self.args.criter.lower() == 'smape':
+ criterion = SymmetricMeanAbsolutePercentageError()
+ elif self.args.criter.lower() == 'mae':
+ criterion = nn.L1Loss()
+ elif self.args.criter.lower() == 'rmse':
+ criterion = RMSELoss()
+ elif self.args.criter.lower() == 'quantileloss':
+ criterion = QuantileLoss()
+ elif self.args.criter.lower() == 'huberloss':
+ criterion = HuberLoss()
+ elif self.args.criter.lower() == 'pinballloss':
+ criterion = PinballLoss()
+ else:
+ criterion = nn.MSELoss() # Default to Mean Squared Error
+
return criterion
def vali(self, vali_data, vali_loader, criterion):
total_loss = []
+ trues_during_vali = []
+ preds_during_vali = []
self.model.eval()
with torch.no_grad():
for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(vali_loader):
batch_x = batch_x.float().to(self.device)
batch_y = batch_y.float()
-
+
if 'PEMS' in self.args.data or 'Solar' in self.args.data:
batch_x_mark = None
batch_y_mark = None
else:
batch_x_mark = batch_x_mark.float().to(self.device)
batch_y_mark = batch_y_mark.float().to(self.device)
-
# decoder input
dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float()
dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device)
@@ -69,48 +124,85 @@ def vali(self, vali_data, vali_loader, criterion):
f_dim = -1 if self.args.features == 'MS' else 0
outputs = outputs[:, -self.args.pred_len:, f_dim:]
batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device)
-
+
pred = outputs.detach().cpu()
true = batch_y.detach().cpu()
-
+
loss = criterion(pred, true)
-
+ trues_during_vali.append(batch_y.detach().cpu().numpy())
+ preds_during_vali.append(outputs.detach().cpu().numpy())
+
total_loss.append(loss)
+
total_loss = np.average(total_loss)
self.model.train()
+ try:
+ if len(self.trues_during_vali) == 0:
+ trues_during_vali = np.array(trues_during_vali)
+ preds_during_vali = np.array(preds_during_vali)
+ self.trues_during_vali = trues_during_vali.reshape(-1, trues_during_vali.shape[-2], trues_during_vali.shape[-1])
+ self.preds_during_vali = preds_during_vali.reshape(-1, preds_during_vali.shape[-2], preds_during_vali.shape[-1])
+ else:
+ shape_self_true = self.trues_during_vali.shape
+ shape_self_pred = self.preds_during_vali.shape
+
+ trues_during_vali = np.array(trues_during_vali)
+ preds_during_vali = np.array(preds_during_vali)
+ trues_during_vali = trues_during_vali.reshape(-1, trues_during_vali.shape[-2], trues_during_vali.shape[-1])
+ preds_during_vali = preds_during_vali.reshape(-1, preds_during_vali.shape[-2], preds_during_vali.shape[-1])
+ shape_funv_true = trues_during_vali.shape
+ shape_funv_pred = preds_during_vali.shape
+
+ self.trues_during_vali = self.trues_during_vali.flatten().tolist()
+ self.preds_during_vali = self.preds_during_vali.flatten().tolist()
+ trues_during_vali = trues_during_vali.flatten().tolist()
+ preds_during_vali = preds_during_vali.flatten().tolist()
+ trues_during_vali = self.trues_during_vali + trues_during_vali
+ preds_during_vali = self.preds_during_vali + preds_during_vali
+
+ trues_during_vali = np.array(trues_during_vali)
+ preds_during_vali = np.array(preds_during_vali)
+ self.trues_during_vali = trues_during_vali.reshape(shape_funv_true[0]+shape_self_true[0], shape_self_true[1], shape_self_true[2])
+ self.preds_during_vali = preds_during_vali.reshape(shape_self_pred[0]+shape_funv_pred[0], shape_self_pred[1],shape_self_pred[2])
+ except:
+ pass
return total_loss
-
+
+
def train(self, setting):
train_data, train_loader = self._get_data(flag='train')
vali_data, vali_loader = self._get_data(flag='val')
test_data, test_loader = self._get_data(flag='test')
-
+
+ trues_during_training = []
+ preds_during_training = []
+
path = os.path.join(self.args.checkpoints, setting)
if not os.path.exists(path):
os.makedirs(path)
-
+
time_now = time.time()
-
+
train_steps = len(train_loader)
early_stopping = EarlyStopping(patience=self.args.patience, verbose=True)
-
+
model_optim = self._select_optimizer()
criterion = self._select_criterion()
-
+
if self.args.use_amp:
scaler = torch.cuda.amp.GradScaler()
-
+
for epoch in range(self.args.train_epochs):
iter_count = 0
train_loss = []
-
+
self.model.train()
epoch_time = time.time()
for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(train_loader):
iter_count += 1
model_optim.zero_grad()
batch_x = batch_x.float().to(self.device)
-
+
batch_y = batch_y.float().to(self.device)
if 'PEMS' in self.args.data or 'Solar' in self.args.data:
batch_x_mark = None
@@ -118,11 +210,11 @@ def train(self, setting):
else:
batch_x_mark = batch_x_mark.float().to(self.device)
batch_y_mark = batch_y_mark.float().to(self.device)
-
+
# decoder input
dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float()
dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device)
-
+
# encoder - decoder
if self.args.use_amp:
with torch.cuda.amp.autocast():
@@ -130,7 +222,7 @@ def train(self, setting):
outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0]
else:
outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)
-
+
f_dim = -1 if self.args.features == 'MS' else 0
outputs = outputs[:, -self.args.pred_len:, f_dim:]
batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device)
@@ -141,13 +233,15 @@ def train(self, setting):
outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)[0]
else:
outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)
-
+
f_dim = -1 if self.args.features == 'MS' else 0
outputs = outputs[:, -self.args.pred_len:, f_dim:]
batch_y = batch_y[:, -self.args.pred_len:, f_dim:].to(self.device)
loss = criterion(outputs, batch_y)
+ preds_during_training.append(outputs.detach().cpu().numpy())
+ trues_during_training.append(batch_y.detach().cpu().numpy())
train_loss.append(loss.item())
-
+
if (i + 1) % 100 == 0:
print("\titers: {0}, epoch: {1} | loss: {2:.7f}".format(i + 1, epoch + 1, loss.item()))
speed = (time.time() - time_now) / iter_count
@@ -155,7 +249,7 @@ def train(self, setting):
print('\tspeed: {:.4f}s/iter; left time: {:.4f}s'.format(speed, left_time))
iter_count = 0
time_now = time.time()
-
+
if self.args.use_amp:
scaler.scale(loss).backward()
scaler.step(model_optim)
@@ -163,28 +257,80 @@ def train(self, setting):
else:
loss.backward()
model_optim.step()
-
+
print("Epoch: {} cost time: {}".format(epoch + 1, time.time() - epoch_time))
train_loss = np.average(train_loss)
vali_loss = self.vali(vali_data, vali_loader, criterion)
test_loss = self.vali(test_data, test_loader, criterion)
-
+ self.train_losses.append(train_loss)
+ self.test_losses.append(test_loss)
+ self.vali_losses.append(vali_loss)
print("Epoch: {0}, Steps: {1} | Train Loss: {2:.7f} Vali Loss: {3:.7f} Test Loss: {4:.7f}".format(
epoch + 1, train_steps, train_loss, vali_loss, test_loss))
early_stopping(vali_loss, self.model, path)
if early_stopping.early_stop:
print("Early stopping")
break
-
+
adjust_learning_rate(model_optim, epoch + 1, self.args)
-
+
# get_cka(self.args, setting, self.model, train_loader, self.device, epoch)
-
+
best_model_path = path + '/' + 'checkpoint.pth'
self.model.load_state_dict(torch.load(best_model_path))
-
+
+ preds_during_training = np.array(preds_during_training)
+ trues_during_training = np.array(trues_during_training)
+ print('\n')
+ print('train shape:', preds_during_training.shape, trues_during_training.shape)
+ preds_during_training = preds_during_training.reshape(-1, preds_during_training.shape[-2], preds_during_training.shape[-1])
+ trues_during_training = trues_during_training.reshape(-1, trues_during_training.shape[-2], trues_during_training.shape[-1])
+ print('train shape:', preds_during_training.shape, trues_during_training.shape)
+ # result save
+ folder_path = './results/' + setting + '/'
+ if not os.path.exists(folder_path):
+ os.makedirs(folder_path)
+
+ mae, mse, rmse, mape, mspe = metric(preds_during_training, trues_during_training)
+
+ print('Train mse:{},Train mae:{}'.format(mse, mae))
+ print('Train rmse:{},Train mape:{}'.format(rmse, mape))
+ print('\n')
+ time.sleep(2)
+ f = open("result_long_term_forecast.txt", 'a')
+ f.write(setting + " \n")
+ f.write('Train mse:{},Train mae:{}'.format(mse, mae))
+ f.write('\n')
+ f.write('\n')
+ f.close()
+
+ np.save(folder_path + 'metrics_during_training.npy', np.array([mae, mse, rmse, mape, mspe]))
+ np.save(folder_path + 'preds_during_training.npy', preds_during_training)
+ np.save(folder_path + 'trues_during_training.npy', trues_during_training)
+ try:
+ preds_during_vali = np.array(self.preds_during_vali)
+ trues_during_vali = np.array(self.trues_during_vali)
+ print('Validate shape:', (preds_during_vali.shape[0]//self.args.batch_size, self.args.batch_size, preds_during_vali.shape[1],preds_during_vali.shape[2]),(trues_during_vali.shape[0]//self.args.batch_size, self.args.batch_size, trues_during_vali.shape[1],trues_during_vali.shape[2]))
+ preds_during_vali = preds_during_vali.reshape(-1, preds_during_vali.shape[-2], preds_during_vali.shape[-1])
+ trues_during_vali = trues_during_vali.reshape(-1, trues_during_vali.shape[-2], trues_during_vali.shape[-1])
+ print('Validate shape:', preds_during_vali.shape, trues_during_vali.shape)
+
+ mae, mse, rmse, mape, _ = metric(preds_during_vali, trues_during_vali)
+ print('Validate mse:{},Validate mae:{}'.format(mse, mae))
+ print('Validate rmse:{},Validate mape:{}'.format(rmse, mape))
+ print('\n')
+ time.sleep(2)
+ f = open("result_long_term_forecast.txt", 'a')
+ f.write("Validate Info:" + " \n")
+ f.write('mse:{}, mae:{}'.format(mse, mae))
+ f.write('\n')
+ f.write('\n')
+ f.close()
+ except:
+ pass
return self.model
-
+
+
def test(self, setting, test=0):
test_data, test_loader = self._get_data(flag='test')
if test:
@@ -236,10 +382,10 @@ def test(self, setting, test=0):
shape = outputs.shape
outputs = test_data.inverse_transform(outputs.squeeze(0)).reshape(shape)
batch_y = test_data.inverse_transform(batch_y.squeeze(0)).reshape(shape)
-
+
pred = outputs
true = batch_y
-
+
preds.append(pred)
trues.append(true)
if i % 20 == 0:
@@ -249,8 +395,9 @@ def test(self, setting, test=0):
input = test_data.inverse_transform(input.squeeze(0)).reshape(shape)
gt = np.concatenate((input[0, :, -1], true[0, :, -1]), axis=0)
pd = np.concatenate((input[0, :, -1], pred[0, :, -1]), axis=0)
- visual(gt, pd, os.path.join(folder_path, str(i) + '.pdf'))
-
+ if self.args.do_visual:
+ visual(gt, pd, os.path.join(folder_path, str(i) + '.pdf'))
+
preds = np.array(preds)
trues = np.array(trues)
print('test shape:', preds.shape, trues.shape)
@@ -264,14 +411,15 @@ def test(self, setting, test=0):
os.makedirs(folder_path)
mae, mse, rmse, mape, mspe = metric(preds, trues)
- print('mse:{}, mae:{}'.format(mse, mae))
+ print('Test mse:{},Test mae:{}'.format(mse, mae))
+ print('Test rmse:{},Test mape:{}'.format(rmse, mape))
f = open("result_long_term_forecast.txt", 'a')
f.write(setting + " \n")
f.write('mse:{}, mae:{}'.format(mse, mae))
f.write('\n')
f.write('\n')
f.close()
-
+
np.save(folder_path + 'metrics.npy', np.array([mae, mse, rmse, mape, mspe]))
np.save(folder_path + 'pred.npy', preds)
np.save(folder_path + 'true.npy', trues)
@@ -281,14 +429,14 @@ def test(self, setting, test=0):
def predict(self, setting, load=False):
pred_data, pred_loader = self._get_data(flag='pred')
-
+
if load:
path = os.path.join(self.args.checkpoints, setting)
best_model_path = path + '/' + 'checkpoint.pth'
self.model.load_state_dict(torch.load(best_model_path))
-
+
preds = []
-
+
self.model.eval()
with torch.no_grad():
for i, (batch_x, batch_y, batch_x_mark, batch_y_mark) in enumerate(pred_loader):
@@ -296,7 +444,7 @@ def predict(self, setting, load=False):
batch_y = batch_y.float()
batch_x_mark = batch_x_mark.float().to(self.device)
batch_y_mark = batch_y_mark.float().to(self.device)
-
+
# decoder input
dec_inp = torch.zeros_like(batch_y[:, -self.args.pred_len:, :]).float()
dec_inp = torch.cat([batch_y[:, :self.args.label_len, :], dec_inp], dim=1).float().to(self.device)
@@ -313,19 +461,23 @@ def predict(self, setting, load=False):
else:
outputs = self.model(batch_x, batch_x_mark, dec_inp, batch_y_mark)
outputs = outputs.detach().cpu().numpy()
+ batch_y = batch_y.detach().cpu().numpy()
+ self.batch_y = batch_y
if pred_data.scale and self.args.inverse:
shape = outputs.shape
outputs = pred_data.inverse_transform(outputs.squeeze(0)).reshape(shape)
preds.append(outputs)
-
+
preds = np.array(preds)
preds = preds.reshape(-1, preds.shape[-2], preds.shape[-1])
-
# result save
folder_path = './results/' + setting + '/'
if not os.path.exists(folder_path):
os.makedirs(folder_path)
-
- np.save(folder_path + 'real_prediction.npy', preds)
-
- return
\ No newline at end of file
+
+ pred_save_path = folder_path + 'Preds real_prediction.npy'
+ np.save(folder_path + 'Preds real_prediction.npy', preds)
+
+ print(f'''The Results of Prediction for The Next {self.args.pred_len} Days Are Now Stored in
+ {pred_save_path}''')
+ return
diff --git a/experiments/pre_train.py b/experiments/pre_train.py
new file mode 100644
index 000000000..61df5b092
--- /dev/null
+++ b/experiments/pre_train.py
@@ -0,0 +1,92 @@
+import os
+import json
+import time
+import tempfile
+
+class DotDict:
+
+ def __init__(self, dictionary):
+ self.__dict__.update(dictionary)
+
+ def __getattr__(self, attr):
+ try:
+ return self.__dict__[attr]
+ except KeyError:
+ self.__setattr__(attr, False)
+ return self.__dict__[attr]
+
+ def __setattr__(self, key, value):
+ self.__dict__[key] = value
+
+ def __str__(self):
+ return str(self.__dict__)
+
+
+def load_args(path):
+
+ with open(path, 'r') as f:
+ loaded_args = json.load(f)
+
+ return DotDict(loaded_args)
+
+
+
+class SaveArgs:
+
+ def __init__(self, args, path, temporary = False) :
+
+ if not isinstance(args, dict):
+ raise TypeError("THis CLass ONly SUpports DIctionary AS AN INput!")
+ self.args = args
+ self.path = path
+ self.temporary = temporary
+
+ self.__start__()
+
+
+ def __start__(self) :
+
+ temp = {}
+ for any_key, any_val in self.args.items() :
+
+ temp[any_key] = any_val
+
+ self.__save__(temp)
+
+
+ def __path_checker__(self):
+
+ if self.temporary:
+ with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+ file_path = temp_file.name + '.json'
+
+ self.path = file_path
+ return
+ else:
+ os.makedirs( self.path, exist_ok=True)
+ file_path = os.path.join(self.path, 'args.json')
+ if os.path.exists(file_path):
+ base, ext = os.path.splitext(file_path)
+ timestamp = time.strftime("%Y%m%d_%H%M%S")
+ file_path = f"{base}_{timestamp}{ext}"
+
+ self.path = file_path
+
+
+ def __save__(self, arg):
+
+ try:
+ self.__path_checker__()
+ with open(self.path, 'w') as file :
+ json.dump(arg, file)
+ except:
+ print("Fail to Save Args - continue..")
+ return
+ if self.temporary:
+ pass
+ else:
+ print(f"Args Object Saved to {self.path}")
+ #print("It Can be further used by pickle.load()")
+
+ def __repr__(self) -> str:
+ return "cloner174 in github 2024"
\ No newline at end of file
diff --git a/input/pred/DONOTREMOVE b/input/pred/DONOTREMOVE
new file mode 100644
index 000000000..e69de29bb
diff --git a/input/train/DONOTREMOVE b/input/train/DONOTREMOVE
new file mode 100644
index 000000000..e69de29bb
diff --git a/results/DONOTREMOVE b/results/DONOTREMOVE
new file mode 100644
index 000000000..e69de29bb
diff --git a/run.ipynb b/run.ipynb
new file mode 100644
index 000000000..64848784f
--- /dev/null
+++ b/run.ipynb
@@ -0,0 +1,938 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "%pip install reformer_pytorch"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " date | \n",
+ " Open | \n",
+ " High | \n",
+ " Low | \n",
+ " Final | \n",
+ " Volume | \n",
+ " Close | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 2001-03-25 | \n",
+ " 26000 | \n",
+ " 26000 | \n",
+ " 24885 | \n",
+ " 24885 | \n",
+ " 4520 | \n",
+ " 24885 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2001-03-26 | \n",
+ " 24885 | \n",
+ " 24885 | \n",
+ " 24885 | \n",
+ " 24885 | \n",
+ " 45 | \n",
+ " 24885 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 2001-04-08 | \n",
+ " 25000 | \n",
+ " 25000 | \n",
+ " 25000 | \n",
+ " 25000 | \n",
+ " 2000 | \n",
+ " 25000 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 2001-04-10 | \n",
+ " 25003 | \n",
+ " 25003 | \n",
+ " 25003 | \n",
+ " 25003 | \n",
+ " 70 | \n",
+ " 25003 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 2001-04-15 | \n",
+ " 25010 | \n",
+ " 25010 | \n",
+ " 25010 | \n",
+ " 25010 | \n",
+ " 120 | \n",
+ " 25010 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " date | \n",
+ " Close | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 2023-11-08 | \n",
+ " 14300 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2023-11-09 | \n",
+ " 14346 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 2023-11-10 | \n",
+ " 14293 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " date | \n",
+ " Close | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 2023-11-08 | \n",
+ " 14300 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2023-11-09 | \n",
+ " 14346 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 2023-11-10 | \n",
+ " 14293 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 2023-11-11 | \n",
+ " 14247 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 2023-11-12 | \n",
+ " 14255 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 2023-11-13 | \n",
+ " 14212 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " date | \n",
+ " Open | \n",
+ " High | \n",
+ " Low | \n",
+ " Final | \n",
+ " Volume | \n",
+ " Close | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " | 0 | \n",
+ " 2023-11-08 | \n",
+ " 14600 | \n",
+ " 14600 | \n",
+ " 14230 | \n",
+ " 14550 | \n",
+ " 748934 | \n",
+ " 14300 | \n",
+ "
\n",
+ " \n",
+ " | 1 | \n",
+ " 2023-11-09 | \n",
+ " 14446 | \n",
+ " 14716 | \n",
+ " 14172 | \n",
+ " 14544 | \n",
+ " 1912825 | \n",
+ " 14346 | \n",
+ "
\n",
+ " \n",
+ " | 2 | \n",
+ " 2023-11-10 | \n",
+ " 14435 | \n",
+ " 14664 | \n",
+ " 14143 | \n",
+ " 14515 | \n",
+ " 1500316 | \n",
+ " 14293 | \n",
+ "
\n",
+ " \n",
+ " | 3 | \n",
+ " 2023-11-11 | \n",
+ " 14363 | \n",
+ " 14607 | \n",
+ " 14105 | \n",
+ " 14483 | \n",
+ " 1364399 | \n",
+ " 14247 | \n",
+ "
\n",
+ " \n",
+ " | 4 | \n",
+ " 2023-11-12 | \n",
+ " 14398 | \n",
+ " 14598 | \n",
+ " 14097 | \n",
+ " 14460 | \n",
+ " 1341792 | \n",
+ " 14255 | \n",
+ "
\n",
+ " \n",
+ " | 5 | \n",
+ " 2023-11-13 | \n",
+ " 14372 | \n",
+ " 14560 | \n",
+ " 14076 | \n",
+ " 14436 | \n",
+ " 1246474 | \n",
+ " 14212 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "