Tire_Life_Predictor_Transformer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing all the Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from darts import TimeSeries, concatenate\n",
    "from darts.dataprocessing.transformers import Scaler\n",
    "from darts.models import TFTModel\n",
    "from darts.metrics import mape\n",
    "from darts.utils.statistics import check_seasonality, plot_acf\n",
    "from darts.utils.timeseries_generation import datetime_attribute_timeseries\n",
    "from darts.utils.likelihood_models import Likelihood, QuantileRegression\n",
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "from sklearn.gaussian_process.kernels import RBF, WhiteKernel\n",
    "import warnings\n",
    "\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "import logging\n",
    "\n",
    "logging.disable(logging.CRITICAL)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "data = pd.read_csv(\"/home/vnk3019/Gaussian_Reduced_Data.csv\")\n",
    "df = data\n",
    "df = df.dropna()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from darts.models import TFTModel\n",
    "from darts.metrics import mape\n",
    "from darts.timeseries import TimeSeries\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from functools import reduce\n",
    "\n",
    "# default quantiles for QuantileRegression\n",
    "quantiles = [\n",
    "    0.01,\n",
    "    0.05,\n",
    "    0.1,\n",
    "    0.15,\n",
    "    0.2,\n",
    "    0.25,\n",
    "    0.3,\n",
    "    0.4,\n",
    "    0.5,\n",
    "    0.6,\n",
    "    0.7,\n",
    "    0.75,\n",
    "    0.8,\n",
    "    0.85,\n",
    "    0.9,\n",
    "    0.95,\n",
    "    0.99,\n",
    "]\n",
    "\n",
    "# Assuming 'date' column exists\n",
    "df = df.sort_values(by=['Tire_ID', 'age_days'])\n",
    "\n",
    "# Dictionary to store transformed TimeSeries and covariates for each Tire_ID\n",
    "tire_data_dict = {}\n",
    "\n",
    "# Get unique Tire_IDs\n",
    "unique_tire_ids = df['Tire_ID'].unique()\n",
    "\n",
    "# Define the train and validation Tire_IDs using 70:30 split\n",
    "split_idx = int(0.7 * len(unique_tire_ids))\n",
    "train_tire_ids = unique_tire_ids[:split_idx]\n",
    "val_tire_ids = unique_tire_ids[split_idx:]\n",
    "\n",
    "# Collect all covariates in a list\n",
    "all_covariates = []\n",
    "\n",
    "for tire_id, group in df.groupby('Tire_ID'):\n",
    "    # Handle indexing and duplicates\n",
    "    group['age_days'] = group['age_days'].astype(int)\n",
    "    group.set_index('age_days', inplace=True)\n",
    "    \n",
    "    # Ensure a continuous series for 'age_days'\n",
    "    complete_age_days = pd.RangeIndex(start=group.index.min(), stop=group.index.max()+1)\n",
    "    group = group[~group.index.duplicated(keep='first')]\n",
    "    group = group.reindex(complete_age_days).interpolate()\n",
    "    group = group.reset_index().rename(columns={\"index\": \"age_days\"})\n",
    "    \n",
    "    # Create TimeSeries from group\n",
    "    series = TimeSeries.from_dataframe(group, value_cols=['predicted_RCP']).astype(np.float32)\n",
    "\n",
    "    # Create covariates using all columns except 'predicted_RCP' and 'Tire_ID'\n",
    "    covariate_cols = group.columns.difference(['predicted_RCP', 'Tire_ID'])\n",
    "    covariates = TimeSeries.from_dataframe(group, value_cols=covariate_cols).astype(np.float32)\n",
    "\n",
    "    # Add the processed covariates to the list\n",
    "    all_covariates.append(covariates)\n",
    "\n",
    "    # Store series and covariates in the dictionary\n",
    "    tire_data_dict[tire_id] = {'series': series, 'covariates': covariates}\n",
    "\n",
    "# Parameters for training\n",
    "input_chunk_length = 50\n",
    "output_chunk_length = 50\n",
    "\n",
    "# Prepare training and validation datasets\n",
    "training_series = [tire_data_dict[tire_id]['series'] for tire_id in train_tire_ids]\n",
    "training_covariates = [tire_data_dict[tire_id]['covariates'] for tire_id in train_tire_ids]\n",
    "\n",
    "validation_series = [tire_data_dict[tire_id]['series'] for tire_id in val_tire_ids]\n",
    "validation_covariates = [tire_data_dict[tire_id]['covariates'] for tire_id in val_tire_ids]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the saved TFT Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_chunk_length = 50\n",
    "output_chunk_length = 50  # Forecast horizon of 50 time steps\n",
    "\n",
    "from pytorch_lightning.callbacks import Callback\n",
    "# default quantiles for QuantileRegression\n",
    "quantiles = [\n",
    "    0.01,\n",
    "    0.05,\n",
    "    0.1,\n",
    "    0.15,\n",
    "    0.2,\n",
    "    0.25,\n",
    "    0.3,\n",
    "    0.4,\n",
    "    0.5,\n",
    "    0.6,\n",
    "    0.7,\n",
    "    0.75,\n",
    "    0.8,\n",
    "    0.85,\n",
    "    0.9,\n",
    "    0.95,\n",
    "    0.99,\n",
    "]\n",
    "\n",
    "class LossLogger(Callback):\n",
    "    def __init__(self):\n",
    "        self.train_loss = []\n",
    "        self.val_loss = []\n",
    "\n",
    "    # will automatically be called at the end of each epoch\n",
    "    def on_train_epoch_end(self, trainer: \"pl.Trainer\", pl_module: \"pl.LightningModule\") -> None:\n",
    "        self.train_loss.append(float(trainer.callback_metrics[\"train_loss\"]))\n",
    "\n",
    "    def on_validation_epoch_end(self, trainer: \"pl.Trainer\", pl_module: \"pl.LightningModule\") -> None:\n",
    "        self.val_loss.append(float(trainer.callback_metrics[\"val_loss\"]))\n",
    "\n",
    "\n",
    "loss_logger = LossLogger()\n",
    "\n",
    "tft_model = TFTModel(\n",
    "    input_chunk_length=input_chunk_length,\n",
    "    output_chunk_length=output_chunk_length,\n",
    "    hidden_size=64,\n",
    "    lstm_layers=1,\n",
    "    num_attention_heads=4,\n",
    "    dropout=0.1,\n",
    "    batch_size=128,\n",
    "    n_epochs=50,\n",
    "    add_relative_index=False,\n",
    "    add_encoders=None,\n",
    "    likelihood=QuantileRegression(\n",
    "        quantiles=quantiles\n",
    "    ),  # QuantileRegression is set per default\n",
    "    # loss_fn=MSELoss(),\n",
    "    random_state=42,\n",
    "    pl_trainer_kwargs={\"callbacks\": [loss_logger]},\n",
    ")\n",
    "\n",
    "\n",
    "tft_model = tft_model.load(\"/home/vnk3019/RCP_TFT_11202023_nn.pt\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class for TFT Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.gaussian_process import GaussianProcessRegressor\n",
    "from sklearn.gaussian_process.kernels import RBF, WhiteKernel\n",
    "from darts.timeseries import TimeSeries\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.stats import norm\n",
    "\n",
    "class TirePredictor():\n",
    "\n",
    "    def __init__(self, tft_model, df, tire_data_dict):\n",
    "        self.tft_model = tft_model\n",
    "        self.df = df\n",
    "        self.tire_data_dict = tire_data_dict\n",
    "\n",
    "    def predict_with_sliding_windows_and_gp(self, test_tire_id, input_chunk_length, output_chunk_length=None):\n",
    "        actual_series = self.tire_data_dict[test_tire_id]['series']\n",
    "        forecast = self._predict_with_sliding_windows_and_gp_helper(actual_series, self.tire_data_dict[test_tire_id]['covariates'], input_chunk_length, output_chunk_length)\n",
    "\n",
    "        # Extract casing mileage values and interpolate\n",
    "        casing_mileage = self.df[self.df[\"Tire_ID\"] == test_tire_id][\"casing_mileage_kms\"].values\n",
    "        real_casing_mileage = casing_mileage\n",
    "\n",
    "        interpolated_casing_mileage = np.linspace(0, max(real_casing_mileage), len(forecast.values()))\n",
    "\n",
    "        return forecast, interpolated_casing_mileage, actual_series\n",
    "\n",
    "    def _predict_with_sliding_windows_and_gp_helper(self, series, covariates, input_chunk_length, output_chunk_length=None):\n",
    "        total_predictions = np.zeros(len(series))\n",
    "        prediction_counts = np.zeros(len(series))\n",
    "\n",
    "        # Initialize the first `input_chunk_length` entries\n",
    "        total_predictions[:input_chunk_length] = series.values()[:input_chunk_length].flatten()\n",
    "        prediction_counts[:input_chunk_length] = 1\n",
    "\n",
    "        if output_chunk_length == None:\n",
    "            output_chunk_length = len(total_predictions) - 50\n",
    "\n",
    "\n",
    "        all_forecasts = []\n",
    "        all_forecasts_std = []\n",
    "        all_actuals = []\n",
    "\n",
    "        for start in range(0, len(series) - input_chunk_length - output_chunk_length + 1, output_chunk_length):\n",
    "            end = start + input_chunk_length\n",
    "            future_end = end + output_chunk_length\n",
    "\n",
    "            if start ==0:\n",
    "                input_series_chunk = series[start:end]\n",
    "                input_covariate_chunk = covariates[start:future_end]\n",
    "            else:\n",
    "                input_series_chunk = series[start-50:end-50]\n",
    "                input_covariate_chunk = covariates[start-50:future_end-50]\n",
    "\n",
    "\n",
    "            #print(input_series_chunk)\n",
    "\n",
    "            # Prediction with TFT model\n",
    "            forecast = self.tft_model.predict(n=output_chunk_length, series=input_series_chunk, future_covariates=input_covariate_chunk, num_samples=150, verbose = False)\n",
    "            #print(input_series_chunk.time_index)\n",
    "            #print(input_covariate_chunk.time_index)\n",
    "\n",
    "            all_forecasts.extend(forecast.values())\n",
    "\n",
    "            # Here we directly use the model's std for each forecast\n",
    "            all_forecasts_std.extend(forecast.std().values())\n",
    "            all_actuals.extend(series[end:future_end].values())\n",
    "\n",
    "            for i, value in enumerate(forecast.values().tolist()):\n",
    "                total_predictions[end + i] += value\n",
    "                prediction_counts[end + i] += 1\n",
    "\n",
    "            # Use the forecast to update the series for the next window\n",
    "            forecast_values = forecast.values()\n",
    "            series = TimeSeries.from_times_and_values(series.time_index, np.concatenate([series.values()[:end], forecast_values, series.values()[end + output_chunk_length:]]))\n",
    "\n",
    "\n",
    "        return forecast\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single Tire_ID Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "input_chunk_length = 50\n",
    "test_tire_id = 'STX01'\n",
    "tire_predictor = TirePredictor(tft_model, df, tire_data_dict)\n",
    "forecast_1, interpolated_casing_mileage_1, _ = tire_predictor.predict_with_sliding_windows_and_gp(test_tire_id, input_chunk_length, output_chunk_length=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def plot_tire_forecast(interpolated_casing_mileage, forecast, test_tire_id, confidence_interval=0.8):\n",
    "    lower_bound = (1 - confidence_interval) / 2\n",
    "    upper_bound = 1 - lower_bound\n",
    "\n",
    "    plt.plot(interpolated_casing_mileage, forecast.mean().values(), label=f\"RCP of Tire ID {test_tire_id}\")\n",
    "    plt.fill_between(interpolated_casing_mileage, \n",
    "                     forecast.quantile(quantile=lower_bound).values().flatten(), \n",
    "                     forecast.quantile(quantile=upper_bound).values().flatten(), \n",
    "                     alpha=0.3, color='grey', \n",
    "                     label=f'Confidence Interval for Tire ID {test_tire_id}')\n",
    "    plt.title(f\"Remaining Casing Potential of Tire {test_tire_id}\")\n",
    "    plt.xlabel(\"Distance in kms\")\n",
    "    plt.ylabel(\"RCP of Tire\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "plot_tire_forecast(interpolated_casing_mileage_1, forecast_1, test_tire_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "darts_env",
   "language": "python",
   "name": "python3"
  },
  "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.8.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}