add check point file

PeakTimePrediction/.ipynb_checkpoints/Untitled-checkpoint.ipynb

+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 88,
+   "id": "9d700331",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "import keras\n",
+    "import logging\n",
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.tree import DecisionTreeRegressor\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import MinMaxScaler, LabelEncoder\n",
+    "from sklearn.metrics import mean_squared_error as mse, mean_absolute_error as mae\n",
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Dense, Dropout\n",
+    "from joblib import dump\n",
+    "import tensorflow as tf"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 89,
+   "id": "f65c8027",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class MultiColumnLabelEncoder:\n",
+    "    def __init__(self, columns = None):\n",
+    "        # array of column names to encode\n",
+    "        self.columns = columns\n",
+    "\n",
+    "    def fit(self, X, y=None):\n",
+    "        # not relevant here\n",
+    "        return self\n",
+    "\n",
+    "    def transform(self,X):\n",
+    "        output = X.copy()\n",
+    "        if self.columns is not None:\n",
+    "            for col in self.columns:\n",
+    "                output[col] = LabelEncoder().fit_transform(output[col])\n",
+    "        else:\n",
+    "            for colname,col in output.iteritems():\n",
+    "                output[colname] = LabelEncoder().fit_transform(col)\n",
+    "        return output\n",
+    "\n",
+    "    def fit_transform(self, X, y=None):\n",
+    "        return self.fit(X, y).transform(X)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 90,
+   "id": "44ca2765",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def get_scores(y_true, y_pred, x_test):\n",
+    "    try:\n",
+    "        assert (y_true.shape[0] == y_pred.shape[0])\n",
+    "        print(\"RMSE {}\".format(np.sqrt(mse(y_true, y_pred))))\n",
+    "        mean_absolute_deviations = mae(y_true, y_pred)\n",
+    "        print(\"MAE {}\".format(mean_absolute_deviations))\n",
+    "        mean_absolute_deviations = mean_absolute_deviations\n",
+    "    except AssertionError as error:\n",
+    "        logging.error(\"Unequal number of observations\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 93,
+   "id": "3ea3e20b",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Day</th>\n",
+       "      <th>Type</th>\n",
+       "      <th>Time</th>\n",
+       "      <th>Condition</th>\n",
+       "      <th>Count</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Monday</td>\n",
+       "      <td>Car</td>\n",
+       "      <td>7.45 AM</td>\n",
+       "      <td>Rainy</td>\n",
+       "      <td>20</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>TuseDay</td>\n",
+       "      <td>Jeep</td>\n",
+       "      <td>8.00 AM</td>\n",
+       "      <td>Cloudy</td>\n",
+       "      <td>30</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Thursday</td>\n",
+       "      <td>Van</td>\n",
+       "      <td>8.05 AM</td>\n",
+       "      <td>Light Rain</td>\n",
+       "      <td>10</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Friday</td>\n",
+       "      <td>Bike</td>\n",
+       "      <td>8.10 AM</td>\n",
+       "      <td>Rainy</td>\n",
+       "      <td>21</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Saturday</td>\n",
+       "      <td>Car</td>\n",
+       "      <td>8.15 AM</td>\n",
+       "      <td>Windy</td>\n",
+       "      <td>12</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        Day  Type     Time   Condition  Count\n",
+       "0  Monday    Car   7.45 AM  Rainy       20   \n",
+       "1  TuseDay   Jeep  8.00 AM  Cloudy      30   \n",
+       "2  Thursday  Van   8.05 AM  Light Rain  10   \n",
+       "3  Friday    Bike  8.10 AM  Rainy       21   \n",
+       "4  Saturday  Car   8.15 AM  Windy       12   "
+      ]
+     },
+     "execution_count": 93,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "columns = [\"Day\",\"Type\",\"Time\",\"Condition\",\"Count\"]\n",
+    "data = pd.read_csv(os.path.join('datax.csv'), names = columns, skiprows=1)\n",
+    "pd.set_option('display.max_colwidth', 1)\n",
+    "data.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 94,
+   "id": "06b9364f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def scaling_operation(do_scaling, X, y):\n",
+    "\n",
+    "    try:\n",
+    "        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)\n",
+    "\n",
+    "        if do_scaling:\n",
+    "            scaler_x_minmax = MinMaxScaler()\n",
+    "\n",
+    "            scaler_x_minmax.fit(X_train)\n",
+    "            X_train_scaled = scaler_x_minmax.transform(X_train)\n",
+    "\n",
+    "            X_test_scaled = scaler_x_minmax.transform(X_test)\n",
+    "\n",
+    "            scaler_y_minmax = MinMaxScaler()\n",
+    "            scaler_y_minmax.fit(y_train)\n",
+    "            y_train_scaled = scaler_y_minmax.transform(y_train)\n",
+    "\n",
+    "            y_test_scaled = scaler_y_minmax.transform(y_test)\n",
+    "\n",
+    "            return scaler_y_minmax, X_train_scaled, X_test_scaled, y_train_scaled, y_test_scaled, scaler_x_minmax\n",
+    "\n",
+    "        else:\n",
+    "\n",
+    "            return None, X_train, X_test, y_train, y_test, None\n",
+    "    except:\n",
+    "        logging.error(\"Something went wrong...\")\n",
+    "\n",
+    "\n",
+    "def get_plots(y_true, y_pred, x_tick_labels):\n",
+    "    try:\n",
+    "        assert (y_true.shape[0] == y_pred.shape[0])\n",
+    "        fig = plt.figure()\n",
+    "        ax1 = fig.add_subplot(1, 1, 1)\n",
+    "        xc = np.arange(len(x_tick_labels))\n",
+    "        ax1.plot(xc, y_pred, label='pred')\n",
+    "        ax1.plot(xc, y_true, label='true')\n",
+    "        ax1.set_ylabel(\"Count Per Day\")\n",
+    "        plt.legend()\n",
+    "        plt.show()\n",
+    "\n",
+    "    except AssertionError as error:\n",
+    "        logging.error(\"Unequal number of samples in output\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "def pre_process(data):\n",
+    "    try:\n",
+    "        Day = data.iloc[:, 0].astype(str)\n",
+    "        Type = data.iloc[:, 1].astype(str)\n",
+    "        Time = data.iloc[:, 2].astype(str)\n",
+    "        Condition = data.iloc[:, 3].astype(str)\n",
+    "        Count = data.iloc[:, 4].fillna(0)\n",
+    "\n",
+    "        # stack independent and dependent feature variables\n",
+    "        processed_data = pd.concat([Day,Type,Time,Condition,Count], axis=1)\n",
+    "        # processed_data = pd.DataFrame(processed_data)\n",
+    "        \n",
+    "        # data with label encoding (get the unique number for each unique observation)\n",
+    "        encodedData = MultiColumnLabelEncoder(\n",
+    "            columns=[\"Day\",\"Type\",\"Time\",\"Condition\"]).fit_transform(processed_data)\n",
+    "\n",
+    "        # getting all the raw data features\n",
+    "        #raw_data_features = encodedData.iloc[:, 0:-1].values\n",
+    "        # getting the target value\n",
+    "        raw_data_target = encodedData.iloc[:, 4].values.reshape(-1, 1)\n",
+    "\n",
+    "        # mutual information graph\n",
+    "        # mutual_info_regr(raw_data_features, raw_data_target)\n",
+    "\n",
+    "        # Choosing the best features based on mutual information graph\n",
+    "        best_feature_1 = encodedData.iloc[:, 1]\n",
+    "        best_feature_2 = encodedData.iloc[:, 3]\n",
+    "\n",
+    "        train_data_X = pd.concat([best_feature_1, best_feature_2], axis=1)\n",
+    "        target_data_y = raw_data_target\n",
+    "\n",
+    "        # set the scaling true (scaled data) or false (processed raw data)\n",
+    "        scaling = True\n",
+    "\n",
+    "        # all features and target scaled/raw (Scaled -> True/False) data\n",
+    "        scaler_y_minmax, X_train_scaled, X_test_scaled, \\\n",
+    "        y_train_scaled, y_test_scaled, scaler_x_minmax = scaling_operation(scaling, train_data_X,\n",
+    "                                                                           target_data_y)\n",
+    "\n",
+    "        # test instances are saved for latter plotting purposes\n",
+    "        test_instances = X_test_scaled[:, 0]\n",
+    "\n",
+    "        return scaler_y_minmax, X_train_scaled, X_test_scaled, y_train_scaled, y_test_scaled, scaler_x_minmax, test_instances\n",
+    "\n",
+    "    except AssertionError as error:\n",
+    "        print(\"input data cannot have NaN or Inf values\")\n",
+    "\n",
+    "def train(X, y, use_keras=False, params=None):\n",
+    "    try:\n",
+    "        assert (X.shape[0] == y.shape[0])\n",
+    "        logging.info(\"Training model\")\n",
+    "        if params == None:\n",
+    "\n",
+    "            num_layers = 2\n",
+    "            num_neurons = 130\n",
+    "            activation = 'relu'\n",
+    "            learning_rate = 1e-10\n",
+    "            n_epochs = 300\n",
+    "            batch_size = 8\n",
+    "            dropout = Dropout(0.2)\n",
+    "\n",
+    "        else:\n",
+    "            num_layers = params['num_layers']\n",
+    "            num_neurons = params['num_neurons']\n",
+    "            activation = params['activation']\n",
+    "            learning_rate = params['learning_rate']\n",
+    "            n_epochs = params['n_epochs']\n",
+    "            batch_size = params['batch_size']\n",
+    "            dropout = params['dropout']\n",
+    "\n",
+    "        if use_keras:\n",
+    "\n",
+    "            keras.backend.clear_session()\n",
+    "\n",
+    "            # Choose an Optimizer\n",
+    "            optimizer = tf.optimizers.Adam(lr=learning_rate)\n",
+    "\n",
+    "            # Initialize a sequential / feed forward model\n",
+    "            model = Sequential()\n",
+    "\n",
+    "            # Add input and first hidden layer\n",
+    "            model.add(Dense(units=num_neurons, activation=activation, input_dim=X.shape[1]))\n",
+    "\n",
+    "            # add dropout\n",
+    "            model.add(dropout)\n",
+    "\n",
+    "            # Add subsequent hidden layer\n",
+    "            for _ in range(num_layers - 1):\n",
+    "                model.add(Dense(units=num_neurons,\n",
+    "                                    activation=activation\n",
+    "                                    )\n",
+    "                              )\n",
+    "\n",
+    "            # Add Output Layer\n",
+    "            model.add(Dense(units=y.shape[1], activation='relu'))\n",
+    "\n",
+    "            # Compile the regressor\n",
+    "            model.compile(optimizer=optimizer, loss='mae', metrics=['accuracy'])\n",
+    "\n",
+    "            history = model.fit(X, y, validation_split=0.20,\n",
+    "                                    epochs=n_epochs, batch_size=batch_size,\n",
+    "                                    verbose=1, shuffle=True)\n",
+    "\n",
+    "            # summarize history for loss\n",
+    "            plt.plot(history.history['loss'])\n",
+    "            plt.plot(history.history['val_loss'])\n",
+    "            plt.title('Model loss')\n",
+    "            plt.ylabel('Loss (mae)')\n",
+    "            plt.xlabel('Number of epochs')\n",
+    "            plt.legend(['training', 'validation'], loc='upper right')\n",
+    "            plt.grid()\n",
+    "            plt.show()\n",
+    "\n",
+    "        else:\n",
+    "\n",
+    "            model = DecisionTreeRegressor()\n",
+    "            model.fit(X, y)\n",
+    "        return model\n",
+    "\n",
+    "    except AssertionError as error:\n",
+    "        logging.error(\"Unequal number of samples\")\n",
+    "\n",
+    "def predict(model, input):\n",
+    "    logging.info(\"Predicting\")\n",
+    "    output = model.predict(input)\n",
+    "    return output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 95,
+   "id": "09a6d873",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def main(path):\n",
+    "    try:\n",
+    "        assert (path != \"\")\n",
+    "        logging.info(\"Starting pipeline\")\n",
+    "#         data = get_data(path)\n",
+    "\n",
+    "        # checking if the data has been imported correctly\n",
+    "        logging.info(\"Shape of data imported: \" + str(data.shape))\n",
+    "\n",
+    "        # pre processing the data\n",
+    "        scaler_y_minmax, X_train_scaled, X_test_scaled, y_train_scaled, y_test_scaled, scaler_x_minmax, test_instances = pre_process(data)\n",
+    "\n",
+    "        # Hyper parameter tuning for neural network\n",
+    "        param = {}\n",
+    "        param['num_layers'] = 4\n",
+    "        param['num_neurons'] = 130\n",
+    "        param['activation'] = 'relu'\n",
+    "        param['learning_rate'] = 0.01\n",
+    "        param['n_epochs'] = 10\n",
+    "        param['batch_size'] = 64\n",
+    "        param['dropout'] = Dropout(0.3)\n",
+    "\n",
+    "        # training\n",
+    "        model = train(X_train_scaled, y_train_scaled, use_keras=True, params=param)\n",
+    "\n",
+    "        # making predictions on the transformed dataset\n",
+    "        y_pred_scaled = predict(model, X_test_scaled)\n",
+    "\n",
+    "        # inverting the predictions to their original scale\n",
+    "        #y_pred = self.post_process(y_pred_raw, scaler_y)\n",
+    "\n",
+    "        # generating scores\n",
+    "        get_scores(y_test_scaled, y_pred_scaled, X_test_scaled)\n",
+    "\n",
+    "        # persist model if model-accuracy is satisfactory\n",
+    "#             if self.mean_absolute_deviations < 1:\n",
+    "#                 dump(self.model, \"model.pkl\")\n",
+    "\n",
+    "#             # generating plots\n",
+    "        get_plots(y_test_scaled[0:20], y_pred_scaled[0:20], test_instances[0:20])\n",
+    "\n",
+    "        return None\n",
+    "    except AssertionError as error:\n",
+    "\n",
+    "        logging.error(\"Path cannot be null\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 96,
+   "id": "02f45dcd",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\Shan\\AppData\\Roaming\\Python\\Python39\\site-packages\\tensorflow\\python\\keras\\optimizer_v2\\optimizer_v2.py:374: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n",
+      "  warnings.warn(\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10\n",
+      "21/21 [==============================] - 1s 9ms/step - loss: 0.0853 - accuracy: 7.5988e-04 - val_loss: 0.0467 - val_accuracy: 0.0000e+00\n",
+      "Epoch 2/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0505 - accuracy: 7.5988e-04 - val_loss: 0.0465 - val_accuracy: 0.0000e+00\n",
+      "Epoch 3/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0510 - accuracy: 7.5988e-04 - val_loss: 0.0468 - val_accuracy: 0.0000e+00\n",
+      "Epoch 4/10\n",
+      "21/21 [==============================] - 0s 4ms/step - loss: 0.0513 - accuracy: 7.5988e-04 - val_loss: 0.0497 - val_accuracy: 0.0000e+00\n",
+      "Epoch 5/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0515 - accuracy: 7.5988e-04 - val_loss: 0.0475 - val_accuracy: 0.0000e+00\n",
+      "Epoch 6/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0513 - accuracy: 7.5988e-04 - val_loss: 0.0468 - val_accuracy: 0.0000e+00\n",
+      "Epoch 7/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0509 - accuracy: 7.5988e-04 - val_loss: 0.0469 - val_accuracy: 0.0000e+00\n",
+      "Epoch 8/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0505 - accuracy: 7.5988e-04 - val_loss: 0.0464 - val_accuracy: 0.0000e+00\n",
+      "Epoch 9/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0502 - accuracy: 7.5988e-04 - val_loss: 0.0463 - val_accuracy: 0.0000e+00\n",
+      "Epoch 10/10\n",
+      "21/21 [==============================] - 0s 3ms/step - loss: 0.0502 - accuracy: 7.5988e-04 - val_loss: 0.0464 - val_accuracy: 0.0000e+00\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "RMSE 0.0654228443422369\n",
+      "MAE 0.04773583636204511\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "if __name__ == \"__main__\":\n",
+    "    path = \"data.csv\"\n",
+    "    main(path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "530f2e46",
+   "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.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}