fix: target scale (#19)

Author: JulesBelveze

tsa/dataset.py

@@ -7,47 +7,50 @@
 
 class TimeSeriesDataset(object):
     def __init__(self, data, categorical_cols, target_col, seq_length, prediction_window=1):
-        '''
+        """
         :param data: dataset of type pandas.DataFrame
         :param categorical_cols: name of the categorical columns, if None pass empty list
         :param target_col: name of the targeted column
         :param seq_length: window length to use
         :param prediction_window: window length to predict
-        '''
+        """
         self.data = data
         self.categorical_cols = categorical_cols
         self.numerical_cols = list(set(data.columns) - set(categorical_cols) - set(target_col))
         self.target_col = target_col
         self.seq_length = seq_length
         self.prediction_window = prediction_window
-        self.preprocessor = None
-
-    def preprocess_data(self):
-        '''Preprocessing function'''
-        X = self.data.drop(self.target_col, axis=1)
-        y = self.data[self.target_col]
 
         self.preprocessor = ColumnTransformer(
             [("scaler", StandardScaler(), self.numerical_cols),
              ("encoder", OneHotEncoder(), self.categorical_cols)],
             remainder="passthrough"
         )
+        if self.target_col:
+            self.y_scaler = StandardScaler()
+
+    def preprocess_data(self):
+        """Preprocessing function"""
+        X = self.data.drop(self.target_col, axis=1)
+        y = self.data[self.target_col]
 
         X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8, shuffle=False)
         X_train = self.preprocessor.fit_transform(X_train)
         X_test = self.preprocessor.transform(X_test)
 
         if self.target_col:
-            return X_train, X_test, y_train.values, y_test.values
+            y_train = self.y_scaler.fit_transform(y_train)
+            y_test = self.y_scaler.transform(y_test)
+            return X_train, X_test, y_train, y_test
         return X_train, X_test
 
     def frame_series(self, X, y=None):
-        '''
+        """
         Function used to prepare the data for time series prediction
         :param X: set of features
         :param y: targeted value to predict
         :return: TensorDataset
-        '''
+        """
         nb_obs, nb_features = X.shape
         features, target, y_hist = [], [], []
 
@@ -69,11 +72,11 @@ def frame_series(self, X, y=None):
         return TensorDataset(features_var)
 
     def get_loaders(self, batch_size: int):
-        '''
+        """
         Preprocess and frame the dataset
         :param batch_size: batch size
         :return: DataLoaders associated to training and testing data
-        '''
+        """
         X_train, X_test, y_train, y_test = self.preprocess_data()
         nb_features = X_train.shape[1]
 
@@ -83,3 +86,9 @@ def get_loaders(self, batch_size: int):
         train_iter = DataLoader(train_dataset, batch_size=batch_size, shuffle=False, drop_last=True)
         test_iter = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, drop_last=True)
         return train_iter, test_iter, nb_features
+
+    def invert_scale(self, predictions):
+        if isinstance(predictions, torch.Tensor):
+            predictions = predictions.numpy()
+        unscaled = self.y_scaler.inverse_transform(predictions)
+        return torch.Tensor(unscaled)

tsa/eval.py

@@ -7,7 +7,7 @@
 from tqdm import tqdm
 
 
-def evaluate(test_iter, criterion, model, config):
+def evaluate(test_iter, criterion, model, config, ts):
     """
     Evaluate the model on the given test set.
 
@@ -39,18 +39,21 @@ def evaluate(test_iter, criterion, model, config):
             targets.append(target.squeeze(1).cpu())
             attentions.append(att.cpu())
 
+    predictions, targets = torch.cat(predictions), torch.cat(targets)
 
     if config['do_eval']:
+        preds, targets = ts.invert_scale(predictions), ts.invert_scale(targets)
+
         plt.figure()
-        plt.plot(torch.cat(predictions), linewidth=.3)
-        plt.plot(torch.cat(targets), linewidth=.3)
+        plt.plot(preds, linewidth=.3)
+        plt.plot(targets, linewidth=.3)
         plt.savefig("{}/preds.png".format(config["output_dir"]))
 
-        torch.save(torch.cat(targets), os.path.join(config['output_dir'], "targets.pt"))
-        torch.save(torch.cat(predictions), os.path.join(config['output_dir'], "predictions.pt"))
-        torch.save(torch.cat(attentions), os.path.join(config['output_dir'], "attentions.pt"))
+        torch.save(targets, os.path.join(config['output_dir'], "targets.pt"))
+        torch.save(predictions, os.path.join(config['output_dir'], "predictions.pt"))
+        torch.save(attentions, os.path.join(config['output_dir'], "attentions.pt"))
 
-    results = get_eval_report(eval_loss / len(test_iter), torch.cat(predictions), torch.cat(targets))
+    results = get_eval_report(eval_loss / len(test_iter), predictions, targets)
     file_eval = os.path.join(config['output_dir'], "eval_results.txt")
     with open(file_eval, "w") as f:
         f.write("********* EVAL REPORT ********\n")

tsa/main.py

@@ -3,11 +3,11 @@
 import argparse
 import pandas as pd
 import torch.nn as nn
-from config import config
-from dataset import TimeSeriesDataset
-from model import AutoEncForecast
-from train import train
-from eval import evaluate
+from .config import config
+from .dataset import TimeSeriesDataset
+from .model import AutoEncForecast
+from .train import train
+from .eval import evaluate
 
 
 def parse_args():
@@ -40,11 +40,11 @@ def parse_args():
                         help="activate/deactivate L2 regularization")
     parser.add_argument("--denoising", default=config["denoising"], type=lambda x: (str(x).lower() == "true"),
                         help="whether or not to use a denoising autoencoder")
-    parser.add_argument("--do-train", default=False, type=lambda x: (str(x).lower() == "true"),
+    parser.add_argument("--do-train", default=True, type=lambda x: (str(x).lower() == "true"),
                         help="whether or not to train the model")
-    parser.add_argument("--do-eval", default=False, type=lambda x: (str(x).lower() == "true"),
+    parser.add_argument("--do-eval", default=True, type=lambda x: (str(x).lower() == "true"),
                         help="whether or not evaluating the mode")
-    parser.add_argument("--data-path", default="data.csv", help="path to data file")
+    parser.add_argument("--data-path", default='nflx.csv', help="path to data file")
     parser.add_argument("--output-dir", default=config["output_dir"], help="name of folder to output files")
     parser.add_argument("--ckpt", default=None, help="checkpoint path for evaluation")
     return parser.parse_args()
@@ -91,9 +91,9 @@ def run(args):
 
     if config["do_eval"] and config["ckpt"]:
         model, _, loss, epoch = load_checkpoint(config["ckpt"], model, optimizer, config["device"])
-        evaluate(test_iter, loss, model, config)
+        evaluate(test_iter, loss, model, config, ts)
     elif config["do_train"]:
-        train(train_iter, test_iter, model, criterion, optimizer, config)
+        train(train_iter, test_iter, model, criterion, optimizer, config, ts)
 
 
 if __name__ == "__main__":

tsa/train.py

@@ -8,7 +8,7 @@
 from .eval import evaluate
 
 
-def train(train_iter, test_iter, model, criterion, optimizer, config):
+def train(train_iter, test_iter, model, criterion, optimizer, config, ts):
     """
     Training function.
 
@@ -65,7 +65,7 @@ def train(train_iter, test_iter, model, criterion, optimizer, config):
 
                 if global_step % config['logging_steps'] == 0:
                     if config['eval_during_training']:
-                        results = evaluate(test_iter, criterion, model, config)
+                        results = evaluate(test_iter, criterion, model, config, ts)
                         for key, val in results.items():
                             tb_writer_test.add_scalar("eval_{}".format(key), val, global_step)