tda_time_series.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "\n",
    "from tda.activation import TDA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model\n",
    "\n",
    "TDANetwork is a simple Deep Learning Model that takes in a time series and outputs a prediction. The main difference that it uses Temporal Decaying Accumulation (TDA) to process the time series. TDA is a simple way to process time series data that is similar to a moving average. The main difference is that it uses a decaying weight for each time step. This allows the model to focus on more recent data and ignore older data. This is useful for time series data that is constantly changing. For example, stock prices are constantly changing and it is more important to focus on recent data than older data.\n",
    "\n",
    "#### More on Temporal Decaying Accumulation (TDA)\n",
    "\n",
    "Temporal Decaying Accumulator (TDA) is a novel activation function designed for handling time-dependent data in neural networks. The primary objective of TDA is to emphasize the importance of recent information while diminishing the influence of older data. This is achieved through the use of an exponential decay function that computes the weights for inputs based on their age, and a clipping mechanism that limits the maximum value of the output.\n",
    "Key Components of TDA:\n",
    "1. Exponential Decay Function: The TDA activation function incorporates an exponential decay function to compute the weights for each input based on its age. The decay function is defined as:w(t) = a * exp(-t / τ)where t is the time step or age of the input, τ is the time constant that controls the rate of decay, and a is a scaling factor that adjusts the overall magnitude of the weights.\n",
    "2. Weighted Sum of Inputs: TDA computes the weighted sum of inputs within a specified time window. The weighted sum is calculated as:TDA(x_t) = sum(w(t) * x_(t-i)) for i in range(0, N) where x_t is the input at the current time step t, N is the size of the time window, w(t) is the weight function defined earlier, and x_(t-i) is the input at the previous time step t-i.\n",
    "3. Clipping Mechanism: The output of the TDA function is clipped to a maximum value to prevent it from growing indefinitely. The clipped output is computed as:TDA_clipped(x_t) = min(TDA(x_t), V_max)where V_max is the maximum value allowed for the TDA function output.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TDANetwork(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size, time_window, max_value, scaling_factor):\n",
    "        super(TDANetwork, self).__init__()\n",
    "        self.layer1 = nn.Linear(input_size * time_window, hidden_size)\n",
    "        self.ac = TDA(time_window, max_value, scaling_factor)\n",
    "        self.layer2 = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(x.shape[0], -1)  # Flatten the input tensor along the time_window dimension\n",
    "        x = self.layer1(x)\n",
    "        x = x.unsqueeze(-1)  # Add an extra dimension for the time_window\n",
    "        x = self.ac(x)\n",
    "        x = self.layer2(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Download data \n",
    "\n",
    "We're using Individual household electric power consumption from UCI dataset.\n",
    "This archive contains 2075259 measurements gathered in a house located in Sceaux (7km of Paris, France) between December 2006 and November 2010 (47 months).\n",
    "\n",
    "Obtain it from [here](https://archive.ics.uci.edu/ml/machine-learning-databases/00235/household_power_consumption.zip)\n",
    "and unzip it to the same directory as this notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "import pandas as pd\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# Load and preprocess the dataset\n",
    "data_path = 'household_power_consumption.txt'\n",
    "data = pd.read_csv(data_path, sep=';', parse_dates={'dt': ['Date', 'Time']}, infer_datetime_format=True, low_memory=False, na_values=['nan', '?'])\n",
    "data = data.set_index('dt').dropna()\n",
    "data = data.resample('h').mean()\n",
    "\n",
    "# Prepare the data\n",
    "sequence_length = 10\n",
    "X = np.array([data[i: i + sequence_length].values for i in range(len(data) - sequence_length)])\n",
    "y = np.array(data.iloc[sequence_length:]['Global_active_power'].values)\n",
    "\n",
    "X[np.isnan(X)] = 0\n",
    "y[np.isnan(y)] = 0\n",
    "\n",
    "# Scale the data\n",
    "scaler = MinMaxScaler()\n",
    "X = scaler.fit_transform(X.reshape(-1, X.shape[-1])).reshape(X.shape)\n",
    "y = scaler.fit_transform(y.reshape(-1, 1))\n",
    "\n",
    "# Split the data into train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Create DataLoader instances for train and test sets\n",
    "train_data = TensorDataset(torch.tensor(X_train, dtype=torch.float32), torch.tensor(y_train, dtype=torch.float32))\n",
    "test_data = TensorDataset(torch.tensor(X_test, dtype=torch.float32), torch.tensor(y_test, dtype=torch.float32))\n",
    "\n",
    "train_loader = DataLoader(train_data, batch_size=128, shuffle=True)\n",
    "test_loader = DataLoader(test_data, batch_size=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, criterion, optimizer, train_loader, test_loader, num_epochs):\n",
    "    train_losses = []\n",
    "    test_losses = []\n",
    "    for epoch in range(num_epochs):\n",
    "        model.train()\n",
    "        losses = []\n",
    "        for batch_x, batch_y in train_loader:\n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(batch_x)\n",
    "            # print(f'Outputs {outputs} -> y {batch_y}')\n",
    "            loss = criterion(outputs, batch_y)\n",
    "            loss.backward()\n",
    "            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # Apply gradient clipping\n",
    "            optimizer.step()\n",
    "            losses.append(loss.item())\n",
    "\n",
    "        train_losses.append(np.mean(losses))\n",
    "\n",
    "        # Evaluate the model on the test set\n",
    "        model.eval()\n",
    "        tlosses = []\n",
    "        with torch.no_grad():\n",
    "            for batch_x, batch_y in test_loader:\n",
    "                outputs = model(batch_x)\n",
    "                loss = criterion(outputs, batch_y)\n",
    "                tlosses.append(loss.item())\n",
    "\n",
    "        test_losses.append(np.mean(tlosses))\n",
    "\n",
    "        print(f\"\\r{model.ac}: Epoch [{epoch+1}/{num_epochs}], Test Loss: {np.mean(test_losses):.4f}\", end=\"\")\n",
    "    \n",
    "    print()\n",
    "    return train_losses, test_losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TDA(): Epoch [75/75], Test Loss: 0.0038\n"
     ]
    }
   ],
   "source": [
    "input_size = X.shape[-1]\n",
    "hidden_size = 128\n",
    "output_size = 1\n",
    "time_window = sequence_length\n",
    "max_value = 1.0\n",
    "scaling_factor = 0.21\n",
    "learning_rate = 0.01\n",
    "\n",
    "model = TDANetwork(input_size, hidden_size, output_size, time_window, max_value, scaling_factor)\n",
    "criterion = nn.SmoothL1Loss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)  # Use a smaller learning rate\n",
    "\n",
    "num_epochs = 75\n",
    "tda_loss, tda_test_loss = train(model, criterion, optimizer, train_loader, test_loader, num_epochs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing performance with ReLU and LeakyReLU\n",
    "\n",
    "To compare the performance of TDA with ReLU and LeakyReLU, we will use the same model architecture and hyperparameters for tow other popular activation functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ReLU(): Epoch [75/75], Test Loss: 0.0040\n",
      "LeakyReLU(negative_slope=0.01): Epoch [75/75], Test Loss: 0.0040\n"
     ]
    }
   ],
   "source": [
    "class GenericNetwork(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size, ac=nn.ReLU):\n",
    "        super(GenericNetwork, self).__init__()\n",
    "        self.layer1 = nn.Linear(input_size, hidden_size)\n",
    "        self.ac = ac()\n",
    "        self.layer2 = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = x.view(x.size(0), -1)  # Flatten the input tensor along the sequence length dimension\n",
    "        x = self.layer1(x)\n",
    "        x = self.ac(x)\n",
    "        x = self.layer2(x)\n",
    "        return x\n",
    "\n",
    "input_size = X.shape[-1] * X.shape[-2]  # Multiply the sequence length with the number of features\n",
    "\n",
    "model = GenericNetwork(input_size, hidden_size, output_size, ac=nn.ReLU)\n",
    "criterion = nn.SmoothL1Loss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)  # Use a smaller learning rate\n",
    "\n",
    "relu_loss, relu_test_loss = train(model, criterion, optimizer, train_loader, test_loader, num_epochs)\n",
    "\n",
    "model = GenericNetwork(input_size, hidden_size, output_size, ac=nn.LeakyReLU)\n",
    "criterion = nn.SmoothL1Loss()\n",
    "optimizer = optim.Adam(model.parameters(), lr=learning_rate)  # Use a smaller learning rate\n",
    "\n",
    "lrelu_loss, lrelu_test_loss = train(model, criterion, optimizer, train_loader, test_loader, num_epochs)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Results\n",
    "\n",
    "We can see that TDA performs better than ReLU and LeakyReLU. This is because TDA is designed to handle time series data. It is able to focus on more recent data and ignore older data. This is useful for time series data that is constantly changing. As shown in the current example, the function can better predict future consumption per houshold, since the pattern changes over time and it is more important to focus on recent data than older data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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",
    "%matplotlib inline\n",
    "\n",
    "plt.plot(tda_loss, label='TDA')\n",
    "plt.plot(relu_loss, label='ReLU')\n",
    "plt.plot(lrelu_loss, label='LeakyReLU')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}