02-hour-min-experiment.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:48.718814Z",
     "iopub.status.busy": "2023-09-22T20:29:48.718673Z",
     "iopub.status.idle": "2023-09-22T20:29:48.828252Z",
     "shell.execute_reply": "2023-09-22T20:29:48.827006Z",
     "shell.execute_reply.started": "2023-09-22T20:29:48.718799Z"
    }
   },
   "outputs": [],
   "source": [
    "!export TF_BLAS=libopenblas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:48.829287Z",
     "iopub.status.busy": "2023-09-22T20:29:48.829094Z",
     "iopub.status.idle": "2023-09-22T20:29:50.731371Z",
     "shell.execute_reply": "2023-09-22T20:29:50.730806Z",
     "shell.execute_reply.started": "2023-09-22T20:29:48.829270Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/.local/lib/python3.8/site-packages/pandas/core/computation/expressions.py:20: UserWarning: Pandas requires version '2.7.3' or newer of 'numexpr' (version '2.7.1' currently installed).\n",
      "  from pandas.core.computation.check import NUMEXPR_INSTALLED\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import tensorflow\n",
    "import matplotlib.pyplot as plt\n",
    "import glob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:50.732755Z",
     "iopub.status.busy": "2023-09-22T20:29:50.732488Z",
     "iopub.status.idle": "2023-09-22T20:29:50.827684Z",
     "shell.execute_reply": "2023-09-22T20:29:50.827193Z",
     "shell.execute_reply.started": "2023-09-22T20:29:50.732739Z"
    }
   },
   "outputs": [],
   "source": [
    "# construct dataframe from multiple csv files\n",
    "\n",
    "# get list of available csv files\n",
    "csv_files = glob.glob('./data/*.csv')\n",
    "\n",
    "# read each file and create final df\n",
    "dataframes = []\n",
    "for file in csv_files:\n",
    "    temp_df = pd.read_csv(file)\n",
    "    dataframes.append(temp_df)\n",
    "\n",
    "df = pd.concat(dataframes, ignore_index=True)\n",
    "df['Timestamp'] = pd.to_datetime(df['Timestamp'], unit='s')  # convert unix_train time to date time\n",
    "df.sort_values(by='Timestamp', inplace=True)  # sort by timestamp\n",
    "\n",
    "# n_feeatures = 3  # number of features used to train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:50.828719Z",
     "iopub.status.busy": "2023-09-22T20:29:50.828551Z",
     "iopub.status.idle": "2023-09-22T20:29:50.838436Z",
     "shell.execute_reply": "2023-09-22T20:29:50.837988Z",
     "shell.execute_reply.started": "2023-09-22T20:29:50.828703Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "Int64Index: 44979 entries, 38532 to 38531\n",
      "Data columns (total 3 columns):\n",
      " #   Column     Non-Null Count  Dtype         \n",
      "---  ------     --------------  -----         \n",
      " 0   Number     44979 non-null  float64       \n",
      " 1   Timestamp  44979 non-null  datetime64[ns]\n",
      " 2   IP         44979 non-null  object        \n",
      "dtypes: datetime64[ns](1), float64(1), object(1)\n",
      "memory usage: 1.4+ MB\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Feature Eng."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:50.839223Z",
     "iopub.status.busy": "2023-09-22T20:29:50.839054Z",
     "iopub.status.idle": "2023-09-22T20:29:50.841719Z",
     "shell.execute_reply": "2023-09-22T20:29:50.841292Z",
     "shell.execute_reply.started": "2023-09-22T20:29:50.839209Z"
    }
   },
   "outputs": [],
   "source": [
    "def get_time_attr(row: pd.Series, part: str):\n",
    "    \"\"\"Return the specified part of the timestamp.\n",
    "\n",
    "    Args:\n",
    "        row (pd.Series): Dataframe row\n",
    "        part (str): Should be a valid `pandas.Timestamp` attribute\n",
    "\n",
    "    Returns:\n",
    "        any: Specified attribute of the timestamp\n",
    "    \"\"\"\n",
    "    return getattr(row, part)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:50.842432Z",
     "iopub.status.busy": "2023-09-22T20:29:50.842276Z",
     "iopub.status.idle": "2023-09-22T20:29:50.911150Z",
     "shell.execute_reply": "2023-09-22T20:29:50.910723Z",
     "shell.execute_reply.started": "2023-09-22T20:29:50.842417Z"
    }
   },
   "outputs": [],
   "source": [
    "# Get time attributes and add to dataframe\n",
    "needed_time_attrs = [\"hour\", \"minute\"]\n",
    "\n",
    "for attr in needed_time_attrs:\n",
    "    df[attr] = df[\"Timestamp\"].apply(lambda x: get_time_attr(x, attr))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:50.911839Z",
     "iopub.status.busy": "2023-09-22T20:29:50.911689Z",
     "iopub.status.idle": "2023-09-22T20:29:50.914321Z",
     "shell.execute_reply": "2023-09-22T20:29:50.913898Z",
     "shell.execute_reply.started": "2023-09-22T20:29:50.911826Z"
    }
   },
   "outputs": [],
   "source": [
    "# train test split\n",
    "train_fraction = 0.8\n",
    "split_point = int(len(df) * train_fraction)\n",
    "\n",
    "df_train = df.iloc[:split_point]\n",
    "df_test = df.iloc[split_point:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:50.915001Z",
     "iopub.status.busy": "2023-09-22T20:29:50.914851Z",
     "iopub.status.idle": "2023-09-22T20:29:50.918772Z",
     "shell.execute_reply": "2023-09-22T20:29:50.918308Z",
     "shell.execute_reply.started": "2023-09-22T20:29:50.914987Z"
    }
   },
   "outputs": [],
   "source": [
    "# raw sequence data\n",
    "train_raw_seq = np.array(df_train[[\"Number\", \"hour\", \"minute\"]])\n",
    "n_features = train_raw_seq.shape[-1]  # Number of features being used\n",
    "n_look_back = 50  # Number of historical data points to learn for each result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:50.920487Z",
     "iopub.status.busy": "2023-09-22T20:29:50.920330Z",
     "iopub.status.idle": "2023-09-22T20:29:50.924487Z",
     "shell.execute_reply": "2023-09-22T20:29:50.924028Z",
     "shell.execute_reply.started": "2023-09-22T20:29:50.920473Z"
    }
   },
   "outputs": [],
   "source": [
    "# look back sequences\n",
    "def split_sequence(sequence: np.ndarray, n_steps: int, n_features: int):\n",
    "    \"\"\"Make sub sequences of n length and the prediction value and return them\n",
    "\n",
    "    Args:\n",
    "        sequence (numpy.ndarray): The sequence of training data\n",
    "        n_steps (int): How many past data points to look at\n",
    "        n_features (int): Total number of features in given dataset\n",
    "    \"\"\"\n",
    "\n",
    "    x, y = [], []\n",
    "\n",
    "    for i in range(len(sequence)):\n",
    "        # find index of end of current learning slice\n",
    "        end_i = i + n_steps\n",
    "\n",
    "        # check if end is beyond the length of sequence\n",
    "        if end_i > len(sequence) - 1:  # -1 since last element needs to be the prediction value\n",
    "            break\n",
    "        else:\n",
    "            seq_x = sequence[i:end_i]  # training sequence\n",
    "            seq_y = sequence[end_i]  # prediction value\n",
    "\n",
    "            x.append(seq_x)\n",
    "            y.append(seq_y)\n",
    "\n",
    "    # Reshape data\n",
    "    x = np.array(x)\n",
    "    y = np.array(y)\n",
    "\n",
    "    x = x.reshape(x.shape[0], x.shape[1], n_features)  # each internal array contains data of each timestep\n",
    "    y = y.reshape(-1, n_features)\n",
    "    \n",
    "    return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:50.925387Z",
     "iopub.status.busy": "2023-09-22T20:29:50.925238Z",
     "iopub.status.idle": "2023-09-22T20:29:50.981296Z",
     "shell.execute_reply": "2023-09-22T20:29:50.980186Z",
     "shell.execute_reply.started": "2023-09-22T20:29:50.925374Z"
    }
   },
   "outputs": [],
   "source": [
    "# Get train, test splits\n",
    "X_train, y_train = split_sequence(train_raw_seq, n_look_back, n_features)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:50.982100Z",
     "iopub.status.busy": "2023-09-22T20:29:50.981940Z",
     "iopub.status.idle": "2023-09-22T20:29:51.024342Z",
     "shell.execute_reply": "2023-09-22T20:29:51.023137Z",
     "shell.execute_reply.started": "2023-09-22T20:29:50.982084Z"
    }
   },
   "outputs": [],
   "source": [
    "# construct model\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import LSTM, Dense\n",
    "\n",
    "def train_model(X_train, y_train, n_features, n_look_back, activation_function, epoch_count=15, optimizer_algorithm='adam', loss_metric='mean_squared_logarithmic_error'):\n",
    "    # define model\n",
    "    model = Sequential()\n",
    "    model.add(LSTM(n_look_back, activation=activation_function, input_shape=(n_look_back, n_features)))\n",
    "    model.add(Dense(1))\n",
    "    model.compile(optimizer=optimizer_algorithm, loss=loss_metric)\n",
    "\n",
    "    # fit model\n",
    "    history = model.fit(X_train, y_train, epochs=epoch_count, verbose=3, validation_split=0.2)\n",
    "\n",
    "    # plot train and validation loss\n",
    "    plt.plot(history.history[\"loss\"])\n",
    "    plt.plot(history.history[\"val_loss\"])\n",
    "    plt.title(\"Model loss\")\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.legend([\"Train\", \"Validation\"], loc=\"upper right\")\n",
    "    plt.show()\n",
    "\n",
    "    # return trained model object\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:29:51.025041Z",
     "iopub.status.busy": "2023-09-22T20:29:51.024886Z",
     "iopub.status.idle": "2023-09-22T20:31:48.871572Z",
     "shell.execute_reply": "2023-09-22T20:31:48.871098Z",
     "shell.execute_reply.started": "2023-09-22T20:29:51.025026Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n",
      "Epoch 2/15\n",
      "Epoch 3/15\n",
      "Epoch 4/15\n",
      "Epoch 5/15\n",
      "Epoch 6/15\n",
      "Epoch 7/15\n",
      "Epoch 8/15\n",
      "Epoch 9/15\n",
      "Epoch 10/15\n",
      "Epoch 11/15\n",
      "Epoch 12/15\n",
      "Epoch 13/15\n",
      "Epoch 14/15\n",
      "Epoch 15/15\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# ReLu\n",
    "model_1 = train_model(X_train, y_train, n_features, n_look_back, 'relu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:31:48.872473Z",
     "iopub.status.busy": "2023-09-22T20:31:48.872254Z",
     "iopub.status.idle": "2023-09-22T20:31:48.893592Z",
     "shell.execute_reply": "2023-09-22T20:31:48.893136Z",
     "shell.execute_reply.started": "2023-09-22T20:31:48.872456Z"
    }
   },
   "outputs": [],
   "source": [
    "# save model to file\n",
    "model_1_path = './models/02-hour_min-relu.keras'\n",
    "model_1.save(model_1_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:31:48.894376Z",
     "iopub.status.busy": "2023-09-22T20:31:48.894207Z",
     "iopub.status.idle": "2023-09-22T20:33:49.508423Z",
     "shell.execute_reply": "2023-09-22T20:33:49.507816Z",
     "shell.execute_reply.started": "2023-09-22T20:31:48.894361Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n",
      "Epoch 2/15\n",
      "Epoch 3/15\n",
      "Epoch 4/15\n",
      "Epoch 5/15\n",
      "Epoch 6/15\n",
      "Epoch 7/15\n",
      "Epoch 8/15\n",
      "Epoch 9/15\n",
      "Epoch 10/15\n",
      "Epoch 11/15\n",
      "Epoch 12/15\n",
      "Epoch 13/15\n",
      "Epoch 14/15\n",
      "Epoch 15/15\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Sigmoid\n",
    "model_2 = train_model(X_train, y_train, n_features, n_look_back, 'sigmoid')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:33:49.509340Z",
     "iopub.status.busy": "2023-09-22T20:33:49.509091Z",
     "iopub.status.idle": "2023-09-22T20:33:49.524801Z",
     "shell.execute_reply": "2023-09-22T20:33:49.524232Z",
     "shell.execute_reply.started": "2023-09-22T20:33:49.509323Z"
    }
   },
   "outputs": [],
   "source": [
    "# save model to file\n",
    "model_2_path = './models/02-hour_min-sigmoid.keras'\n",
    "model_2.save(model_2_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Evaluate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:33:49.525563Z",
     "iopub.status.busy": "2023-09-22T20:33:49.525377Z",
     "iopub.status.idle": "2023-09-22T20:33:49.529054Z",
     "shell.execute_reply": "2023-09-22T20:33:49.528613Z",
     "shell.execute_reply.started": "2023-09-22T20:33:49.525548Z"
    }
   },
   "outputs": [],
   "source": [
    "# define evaluate function\n",
    "def evaluate_msle(model: tensorflow.keras.models.Sequential, preds: np.array, ground_truths: np.array):\n",
    "    m = tensorflow.keras.metrics.MeanSquaredLogarithmicError()\n",
    "    m.update_state(ground_truths, preds)\n",
    "    metric = m.result().numpy()\n",
    "    m.reset_state()\n",
    "    return metric"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:35:33.630108Z",
     "iopub.status.busy": "2023-09-22T20:35:33.629874Z",
     "iopub.status.idle": "2023-09-22T20:35:33.769376Z",
     "shell.execute_reply": "2023-09-22T20:35:33.768539Z",
     "shell.execute_reply.started": "2023-09-22T20:35:33.630090Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Load models again\n",
    "model_1 = tensorflow.keras.models.load_model(model_1_path)\n",
    "model_2 = tensorflow.keras.models.load_model(model_2_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:36:21.293228Z",
     "iopub.status.busy": "2023-09-22T20:36:21.293000Z",
     "iopub.status.idle": "2023-09-22T20:36:21.311024Z",
     "shell.execute_reply": "2023-09-22T20:36:21.309782Z",
     "shell.execute_reply.started": "2023-09-22T20:36:21.293210Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# test data\n",
    "test_raw_seq = np.array(df_test[[\"Number\", \"hour\", \"minute\"]])\n",
    "X_test, y_test = split_sequence(test_raw_seq, n_look_back, n_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:36:22.375407Z",
     "iopub.status.busy": "2023-09-22T20:36:22.375180Z",
     "iopub.status.idle": "2023-09-22T20:36:24.306998Z",
     "shell.execute_reply": "2023-09-22T20:36:24.306161Z",
     "shell.execute_reply.started": "2023-09-22T20:36:22.375390Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "280/280 [==============================] - 1s 3ms/step\n",
      "280/280 [==============================] - 1s 3ms/step\n"
     ]
    }
   ],
   "source": [
    "# make predictions\n",
    "preds_1 = model_1.predict(X_test)\n",
    "preds_2 = model_2.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2023-09-22T20:36:30.158502Z",
     "iopub.status.busy": "2023-09-22T20:36:30.158256Z",
     "iopub.status.idle": "2023-09-22T20:36:30.180712Z",
     "shell.execute_reply": "2023-09-22T20:36:30.180186Z",
     "shell.execute_reply.started": "2023-09-22T20:36:30.158483Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model 1 MSLE:  10.388537\n",
      "Model 2 MSLE:  0.6216314\n"
     ]
    }
   ],
   "source": [
    "print(\"Model 1 MSLE: \", evaluate_msle(model_1, preds_1, y_test))\n",
    "print(\"Model 2 MSLE: \", evaluate_msle(model_2, preds_2, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}