RUL_BiLSTM_N-CMAPSS.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import copy\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from pickle import load\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.optim import lr_scheduler\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torch.nn.functional as F\n",
    "%matplotlib inline\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_loss_history(train_loss, val_loss):\n",
    "    plt.figure(figsize=(20, 8))\n",
    "    plt.plot(train_loss.index.tolist(), train_loss.tolist(),\n",
    "             lw=3, label='Train Loss')\n",
    "    plt.plot(val_loss.index.tolist(), val_loss.tolist(),\n",
    "             lw=3, label='Validation Loss')\n",
    "    plt.xlabel('Epochs', fontsize=20)\n",
    "    plt.ylabel('Loss', fontsize=20)\n",
    "    plt.title('Training and Validation Loss', fontsize=20)\n",
    "    plt.legend(loc='best', fontsize=16)\n",
    "    plt.grid()\n",
    "    plt.savefig('loss_plot.png')\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "# Training Function\n",
    "def train_model(model, loss_function, optimizer, num_epochs=25):\n",
    "    since = time.time()\n",
    "    best_loss = 1e10\n",
    "    best_model_wts = copy.deepcopy(model.state_dict())\n",
    "    loss_history = {'train': [], 'val': []}\n",
    "\n",
    "    for epoch in range(1, num_epochs+1):\n",
    "        print('\\nEpoch {}/{}'.format(epoch, num_epochs))\n",
    "        print('-' * 10)\n",
    "\n",
    "        # Each epoch has a training phase and a validation phase at every 10 epochs\n",
    "        for phase in ['train', 'val']:\n",
    "            # Set model to training or evaluation mode\n",
    "            model.train() if phase == 'train' else model.eval()\n",
    "            running_loss = 0.0\n",
    "\n",
    "            # Iterate over data.\n",
    "            for idx, (inputs, labels) in tqdm(enumerate(dataloaders[phase]),\n",
    "                                              leave=True,\n",
    "                                              total=len(dataloaders[phase])):\n",
    "\n",
    "                inputs = inputs.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # track history if only in train\n",
    "                with torch.set_grad_enabled(phase == 'train'):\n",
    "                    outputs = model(inputs)\n",
    "                    loss = loss_function(outputs, labels)\n",
    "\n",
    "                    # backward + optimize only if in training phase\n",
    "                    if phase == 'train':\n",
    "                        # zero the parameter gradients\n",
    "                        optimizer.zero_grad()\n",
    "                        loss.backward()\n",
    "                        optimizer.step()\n",
    "\n",
    "                running_loss += loss.item()\n",
    "\n",
    "            # if phase == 'train':\n",
    "            #     scheduler.step()\n",
    "\n",
    "            epoch_loss = running_loss / len(dataloaders[phase])\n",
    "            loss_history[phase].append(epoch_loss)\n",
    "            if epoch % 2 == 0:\n",
    "                if phase == 'train':\n",
    "                    train_stats = '{} ==> Loss: {:.4f}'.format(phase.upper(), epoch_loss)\n",
    "                else:\n",
    "                    # print(train_stats)\n",
    "                    print('\\n'+train_stats+' -- {} ==> Loss: {:.4f}'.format(phase.upper(), epoch_loss))\n",
    "\n",
    "            # deep copy the model\n",
    "            if phase == 'val' and epoch_loss < best_loss:\n",
    "                best_loss = epoch_loss\n",
    "                best_model_wts = copy.deepcopy(model.state_dict())\n",
    "                torch.save(model.state_dict(), 'models/LSTM_v0.pth')\n",
    "\n",
    "    time_elapsed = time.time() - since\n",
    "    print('Training completed in {:.0f}m {:.0f}s'.format(\n",
    "        time_elapsed // 60, time_elapsed % 60))\n",
    "\n",
    "    # load best model weights\n",
    "    model.load_state_dict(best_model_wts)\n",
    "\n",
    "    return model, loss_history\n",
    "\n",
    "\n",
    "class RUL_Estimator(nn.Module):\n",
    "\n",
    "    def __init__(self, n_features, hidden_dim=100, dropout=0.2, seq_length=40, num_layers=2, output_dim=1):\n",
    "        super(RUL_Estimator, self).__init__()\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.seq_length = seq_length\n",
    "        self.num_layers = num_layers\n",
    "\n",
    "        # Define the LSTM layers\n",
    "        self.lstm = nn.LSTM(\n",
    "            input_size=n_features,\n",
    "            hidden_size=self.hidden_dim,\n",
    "            num_layers=self.num_layers,\n",
    "            batch_first=True,\n",
    "            dropout=dropout,\n",
    "            bidirectional=True\n",
    "        )\n",
    "        self.linear = nn.Linear(in_features=self.hidden_dim * 2, out_features=output_dim)\n",
    "\n",
    "    def forward(self, input):\n",
    "        lstm_out, _ = self.lstm(input)\n",
    "        pred = F.relu(self.linear(lstm_out))\n",
    "        # [:, -1, :] as we are interested in the last element of the sequence\n",
    "        return pred[:, -1, :]\n",
    "\n",
    "\n",
    "class CMAPSSDataset(Dataset):\n",
    "    \"\"\"N-CMAPSS dataset.\"\"\"\n",
    "\n",
    "    def __init__(self, csv_file, sep=' ', seq_len=40):\n",
    "        \"\"\"\n",
    "        :param csv_file (string): Path to the csv dataset file.\n",
    "        \"\"\"\n",
    "        self.df_cmapss = pd.read_csv(csv_file, sep=sep)\n",
    "        self.df_data = self.df_cmapss.loc[:, 'unit':'phi']\n",
    "        # drop 'unit' and column 0\n",
    "        self.feature_columns = self.df_data.columns[1:]\n",
    "        self.targets = self.df_cmapss[['unit', 'RUL']]\n",
    "        self.seq_len = seq_len\n",
    "\n",
    "        self.seq_gen = (list(self.gen_sequence(self.df_data[self.df_data['unit'] == id],\n",
    "                                               self.feature_columns))\n",
    "                        for id in self.df_data['unit'].unique() if\n",
    "                        len(self.df_data[self.df_data['unit'] == id]) >= seq_len)\n",
    "\n",
    "        self.seq_data = np.concatenate(list(self.seq_gen)).astype(np.float32)\n",
    "\n",
    "        self.targets_gen = [self.gen_targets(self.targets[self.targets['unit'] == id], ['RUL'])\n",
    "                            for id in self.targets['unit'].unique() if\n",
    "                            len(self.targets[self.targets['unit'] == id]) >= seq_len]\n",
    "\n",
    "        self.seq_targets = np.concatenate(self.targets_gen).astype(np.float32)\n",
    "\n",
    "    # Function to generate sequences of shape: (samples, time steps, features)\n",
    "    def gen_sequence(self, id_df, feature_columns):\n",
    "        \"\"\" Only consider sequences that meets the window-length, no padding is used. This means for testing\n",
    "        we need to drop those which are below the window-length. An alternative would be to pad sequences so that\n",
    "        we can use shorter ones \"\"\"\n",
    "        data_array = id_df[feature_columns].values\n",
    "        num_elements = data_array.shape[0]\n",
    "        if (num_elements != self.seq_len):\n",
    "            for start, stop in zip(range(0, num_elements - self.seq_len), range(self.seq_len, num_elements)):\n",
    "                yield data_array[start:stop, :]\n",
    "        else:\n",
    "            yield data_array[:num_elements, :]\n",
    "\n",
    "    # Function to generate labels\n",
    "    def gen_targets(self, id_df, label):\n",
    "        data_array = id_df[label].values\n",
    "        num_elements = data_array.shape[0]\n",
    "        return data_array[self.seq_len:num_elements, :]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.seq_data) - (self.seq_len - 1)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        data = self.seq_data[idx]\n",
    "        target = self.seq_targets[idx]\n",
    "\n",
    "        data = torch.tensor(data)\n",
    "        target = torch.tensor(target)\n",
    "\n",
    "        return data, target"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# batch_size = 2944\n",
    "# batch_size = 8192\n",
    "# batch_size = 16384\n",
    "sequence_length = 40\n",
    "cmapss_dataset = {x: CMAPSSDataset(csv_file='data/N-CMAPSS/'+x+'_DS03.csv',\n",
    "                                   sep=' ', seq_len=sequence_length)\n",
    "                  for x in ['train', 'val', 'test']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# batch_size = 32768\n",
    "batch_size = 64512\n",
    "dataloaders = {x: DataLoader(cmapss_dataset[x], batch_size=batch_size,\n",
    "                             num_workers=32, pin_memory=True, shuffle=True)\n",
    "               for x in ['train', 'val', 'test']}\n",
    "# for data, labels in dataloaders['train']:\n",
    "#     print(data.shape)\n",
    "#     print(labels.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:0\n",
      "590,601 total number of parameters\n",
      "590,601 parameters to train\n",
      "RUL_Estimator(\n",
      "  (lstm): LSTM(32, 100, num_layers=3, batch_first=True, dropout=0.5, bidirectional=True)\n",
      "  (linear): Linear(in_features=200, out_features=1, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Get some random training examples\n",
    "# sample_data, sample_labels = next(iter(dataloaders['train']))\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)\n",
    "\n",
    "lstm_model = RUL_Estimator(n_features=32,\n",
    "                           hidden_dim=100, dropout=0.5,\n",
    "                           seq_length=sequence_length,\n",
    "                           num_layers=3, output_dim=1)\n",
    "\n",
    "total_params = sum(p.numel() for p in lstm_model.parameters())\n",
    "print(f'{total_params:,} total number of parameters')\n",
    "total_trainable_params = sum(p.numel() for p in lstm_model.parameters() if p.requires_grad)\n",
    "print(f'{total_trainable_params:,} parameters to train')\n",
    "print(lstm_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 1/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/87 [00:00<?, ?it/s]/home/ec2-user/anaconda3/envs/pytorch_latest_p36/lib/python3.6/site-packages/torch/nn/modules/rnn.py:582: UserWarning: RNN module weights are not part of single contiguous chunk of memory. This means they need to be compacted at every call, possibly greatly increasing memory usage. To compact weights again call flatten_parameters(). (Triggered internally at  /opt/conda/conda-bld/pytorch_1607370116979/work/aten/src/ATen/native/cudnn/RNN.cpp:775.)\n",
      "  self.dropout, self.training, self.bidirectional, self.batch_first)\n",
      "100%|██████████| 87/87 [02:35<00:00,  1.79s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 2/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.48s/it]\n",
      "100%|██████████| 34/34 [00:19<00:00,  1.78it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0500 -- VAL ==> Loss: 0.0561\n",
      "\n",
      "Epoch 3/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.49s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 4/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.49s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0236 -- VAL ==> Loss: 0.0248\n",
      "\n",
      "Epoch 5/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:08<00:00,  1.48s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 6/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:08<00:00,  1.48s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.83it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0219 -- VAL ==> Loss: 0.0205\n",
      "\n",
      "Epoch 7/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:08<00:00,  1.48s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 8/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.49s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0170 -- VAL ==> Loss: 0.0144\n",
      "\n",
      "Epoch 9/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.49s/it]\n",
      "100%|██████████| 34/34 [00:19<00:00,  1.72it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 10/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:10<00:00,  1.50s/it]\n",
      "100%|██████████| 34/34 [00:19<00:00,  1.79it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0175 -- VAL ==> Loss: 0.0128\n",
      "\n",
      "Epoch 11/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.49s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.81it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 12/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:12<00:00,  1.52s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0166 -- VAL ==> Loss: 0.0201\n",
      "\n",
      "Epoch 13/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:10<00:00,  1.50s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 14/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:10<00:00,  1.50s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.80it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0155 -- VAL ==> Loss: 0.0156\n",
      "\n",
      "Epoch 15/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:08<00:00,  1.48s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.85it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 16/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.49s/it]\n",
      "100%|██████████| 34/34 [00:19<00:00,  1.71it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0133 -- VAL ==> Loss: 0.0121\n",
      "\n",
      "Epoch 17/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:07<00:00,  1.47s/it]\n",
      "100%|██████████| 34/34 [00:19<00:00,  1.75it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 18/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.49s/it]\n",
      "100%|██████████| 34/34 [00:19<00:00,  1.77it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0143 -- VAL ==> Loss: 0.0136\n",
      "\n",
      "Epoch 19/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.49s/it]\n",
      "100%|██████████| 34/34 [00:18<00:00,  1.82it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch 20/20\n",
      "----------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "100%|██████████| 87/87 [02:09<00:00,  1.49s/it]\n",
      "100%|██████████| 34/34 [00:19<00:00,  1.77it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "TRAIN ==> Loss: 0.0147 -- VAL ==> Loss: 0.0155\n",
      "Training completed in 53m 26s\n",
      "\n",
      "Train Loss: 0.013287419164232138\n",
      "Val Loss: 0.011446853003957692\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# torch.cuda.empty_cache()\n",
    "lstm_model = nn.DataParallel(lstm_model)\n",
    "lstm_model = lstm_model.to(device)\n",
    "\n",
    "loss_function = torch.nn.MSELoss()\n",
    "\n",
    "optimizer = torch.optim.Adam(lstm_model.parameters(), lr=1e-3)\n",
    "\n",
    "lstm_model, loss_history = train_model(lstm_model,\n",
    "                                       loss_function,\n",
    "                                       optimizer,\n",
    "                                       num_epochs=20)\n",
    "\n",
    "print(f'\\nTrain Loss: {np.min(loss_history[\"train\"])}')\n",
    "print(f'Val Loss: {np.min(loss_history[\"val\"])}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Save the training and validation loss for future visualization without\n",
    "# executing the training.\n",
    "results_loss = pd.DataFrame({'train_loss': loss_history['train'],\n",
    "                             'val_loss': loss_history['val']})\n",
    "results_loss.to_csv('results_loss.csv', sep=';', float_format='%.4f')\n",
    "\n",
    "if os.path.exists('results_loss.csv'):\n",
    "    results_loss = pd.read_csv(\"results_loss.csv\", sep=';')\n",
    "\n",
    "plot_loss_history(results_loss['train_loss'], results_loss['val_loss'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prediction on Test Data\n",
    "# load best saved model from the current run\n",
    "# best_model = RUL_Estimator(n_features=32,\n",
    "#                            hidden_dim=100, dropout=0.5,\n",
    "#                            seq_length=sequence_length,\n",
    "#                            num_layers=3, output_dim=1)\n",
    "\n",
    "# if os.path.exists('models/LSTM_v0.pth'):\n",
    "#     best_model.load_state_dict(torch.load('models/LSTM_v0.pth'))\n",
    "#     best_model.to(device)\n",
    "#     print('Loaded LSTM_v0 model.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test RMSE: 8.671842050582605\n"
     ]
    }
   ],
   "source": [
    "# load the scaler\n",
    "target_scaler = load(open('data/N-CMAPSS/target_scaler_DS03.pkl', 'rb'))\n",
    "best_model = lstm_model\n",
    "RMSE = []\n",
    "with torch.no_grad():\n",
    "    for test_data, test_labels in dataloaders['test']:\n",
    "        test_labels = target_scaler.inverse_transform(test_labels)\n",
    "        test_data = test_data.to(device)\n",
    "        pred = best_model(test_data)\n",
    "        pred = target_scaler.inverse_transform(pred.cpu())\n",
    "        RMSE.append(mean_squared_error(test_labels, pred, squared=False))\n",
    "    print(f'Test RMSE: {np.mean(RMSE)}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PyTorch",
   "language": "python",
   "name": "pytorch"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}