cat_data_supervised_MLP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MLP time series predictions\n",
    "MLP method more or less using this method as a source https://machinelearningmastery.com/time-series-forecasting-long-short-term-memory-network-python/\n",
    "\n",
    "tldr: Transform dataset into supervised method, make it stationary, transform to scale, MLP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tnrange\n",
    "from tqdm import tqdm_notebook as tqdm\n",
    "from tqdm import tqdm as tqdm_general\n",
    "import os\n",
    "\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "from keras.models import Sequential\n",
    "from keras.models import load_model\n",
    "from keras.layers import Dense\n",
    "from keras.layers import LSTM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Converting series to supervised and scaling functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# frame a sequence as a supervised learning problem\n",
    "def timeseries_to_supervised(data, lag=1):\n",
    "    df = pd.DataFrame(data)\n",
    "    columns = [df.shift(-i) for i in range(0, lag)]\n",
    "    columns.append(df)\n",
    "    df = pd.concat(columns, axis=1)\n",
    "    df.fillna(0, inplace=True)\n",
    "    return df\n",
    "\n",
    "# speshul scaling\n",
    "def scale2(train_data):\n",
    "    # fit scaler\n",
    "    scaler = MinMaxScaler(feature_range=(-1, 1))\n",
    "    scaler = scaler.fit(train_data)\n",
    "    # transform train\n",
    "    train = train_data.reshape(train_data.shape[0], train_data.shape[1])\n",
    "    train_scaled = scaler.transform(train_data)\n",
    "    return scaler, train_scaled\n",
    "\n",
    "def fit_existing_scaler(train_data, scaler):\n",
    "    train_scaled = scaler.transform(train_data)\n",
    "    return train_scaled\n",
    "\n",
    "# inverse scaling for a forecasted value\n",
    "def invert_scale(scaler, X, value):\n",
    "    new_row = [x for x in X] + [value]\n",
    "    array = np.array(new_row)\n",
    "    array = array.reshape(1, len(array))\n",
    "    inverted = scaler.inverse_transform(array)\n",
    "    return inverted[0, -1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Single model per category approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def create_model(window_length):\n",
    "    model = Sequential()\n",
    "    model.add(Dense(window_length, activation='relu', input_shape=(window_length,)))\n",
    "    model.add(Dense(200))\n",
    "    model.add(Dense(200))\n",
    "    model.add(Dense(100))\n",
    "    model.add(Dense(1))\n",
    "    model.compile(loss='mean_squared_error', optimizer='adam')    \n",
    "    return model\n",
    "\n",
    "def fit_model(model, train, batch_size, nb_epoch):\n",
    "    X, y = train[:, 0:-1], train[:, -1]    \n",
    "    model.fit(X, y, epochs=nb_epoch, batch_size=batch_size, verbose=0, shuffle=False)\n",
    "\n",
    "def generate_new_window(train_scaled, predictions_scaled, window_length, index):\n",
    "    # sufficient number of predictions exist\n",
    "    if index - window_length >= 0:\n",
    "        new_train = predictions_scaled[-window_length:]\n",
    "        return np.asarray(new_train).reshape((1, window_length))\n",
    "    \n",
    "    # insufficient predictions, use some from last train sequence\n",
    "    else:\n",
    "        train_end = train_scaled[0][-(window_length - index):]\n",
    "        new_train = np.concatenate((train_end, predictions_scaled))\n",
    "        return new_train.reshape((1, window_length))\n",
    "    \n",
    "def make_window_predictions(model, train_scaled, scaler, raw_values, number_of_predictions, window_length):\n",
    "    scaled_predictions = list()\n",
    "    predictions = list()\n",
    "    \n",
    "    X_train = train_scaled[-1, -window_length:].reshape((1, window_length))    \n",
    "    yhat = model.predict(X_train, 1)[0, 0]\n",
    "    scaled_predictions.append(yhat)\n",
    "\n",
    "    yhat = invert_scale(scaler, X_train[0], yhat)\n",
    "    yhat = yhat + raw_values[-1]\n",
    "    predictions.append(yhat)\n",
    "    \n",
    "    # Predict N steps into the FUTURE!\n",
    "    for i in range(1, number_of_predictions):\n",
    "        X = generate_new_window(X_train, scaled_predictions, window_length, i)\n",
    "        \n",
    "        yhat = model.predict(X, 1)[0, 0]\n",
    "        scaled_predictions.append(yhat)\n",
    "        \n",
    "        yhat = invert_scale(scaler, X[0], yhat)\n",
    "        yhat = yhat + predictions[-1]\n",
    "        predictions.append(yhat)   \n",
    "    return predictions\n",
    "\n",
    "# Create sliding window dataset\n",
    "def create_dataset(train_series, window_length):\n",
    "    windowed_set = timeseries_to_supervised(train_series, window_length)\n",
    "    windowed_set = windowed_set.iloc[:-window_length]\n",
    "    return windowed_set\n",
    "\n",
    "# predicts from single time series using categorical model\n",
    "def predict_from_model(train_series, model, scaler, n_predictions=1, window_length=5, batch_size=4, nb_epoch=5):\n",
    "    supervised_values = timeseries_to_supervised(train_series, window_length)\n",
    "    supervised_values = supervised_values.iloc[:-window_length].values\n",
    "    \n",
    "    train_scaled = fit_existing_scaler(supervised_values, scaler)\n",
    "    return make_window_predictions(model, train_scaled, scaler, train_series, n_predictions, window_length)\n",
    "    \n",
    "# fits or predicts, returns either predictions or nothing respectively\n",
    "def fit_full_category(train_series, model, window_length=5, batch_size=4, nb_epoch=5):\n",
    "    scaler, train_scaled = scale2(train_series.values)\n",
    "    fit_model(model, train_scaled, batch_size, nb_epoch)\n",
    "    return scaler"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prerequisite dataframes, dictionaries, and lists for training and predicting processes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Prediction lengths for different scopes\n",
    "horizon_lengths = {\"H\" : 48, \"D\" : 14, \"W\" : 13, \"M\" : 18, \"Q\" : 8, \"Y\" : 6}\n",
    "window_lengths = {\"H\" : 96, \"D\" : 28, \"W\" : 26, \"M\" : 36, \"Q\" : 16, \"Y\" : 12}\n",
    "\n",
    "# Scope + category as key for models, i.e daily_finance or w/e\n",
    "datasets = {}\n",
    "models = {}\n",
    "scalers = {}\n",
    "\n",
    "# All filenames for different scopes\n",
    "filenames = os.listdir(\"./data/cut/10000/train/\")\n",
    "#filenames = [\"Hourly.csv\"]\n",
    "\n",
    "# Results\n",
    "results_frame = pd.DataFrame()\n",
    "\n",
    "# Test series frame for plotting or w/e\n",
    "test_frame = pd.DataFrame()\n",
    "\n",
    "# M4 info for information about categories\n",
    "m4_info = pd.read_csv('./data/M4-info.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create windowed dataframes per category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1bfec5d84016418b8a7fd3cbda9a3e92"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "for file in filenames:\n",
    "    train_set = pd.read_csv('./data/cut/10000/train/' + file)\n",
    "        \n",
    "    # Go through all the time series in the scope \n",
    "    for i in tnrange(1, train_set.shape[0], desc=file):\n",
    "        current_series = train_set.iloc[i, 2:].dropna()\n",
    "        series_name = train_set.iloc[i, 1]\n",
    "        series_info = m4_info.loc[m4_info['M4id'] == series_name]\n",
    "            \n",
    "        category_name = series_info['category'].values[0].lower()\n",
    "        scope_name = series_info['SP'].values[0].lower()\n",
    "        model_key = scope_name + \"_\" + category_name\n",
    "            \n",
    "        n_window = window_lengths[series_name[0].upper()]\n",
    "        \n",
    "        if model_key in datasets:\n",
    "            current_dataset = create_dataset(current_series, n_window)\n",
    "            np_combined_data = np.concatenate([datasets[model_key], current_dataset], axis=0)\n",
    "            datasets[model_key] = pd.DataFrame(np_combined_data)\n",
    "        else:\n",
    "            datasets[model_key] = create_dataset(current_series, n_window)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loopy training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1a3ba17582e14bbc8500141bf83d786d"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "t = tqdm(datasets.items(), desc=\"Training\")\n",
    "for model_key, dataset in t:\n",
    "    t.set_description(model_key)\n",
    "    t.refresh() \n",
    "    \n",
    "    n_window = window_lengths[model_key[0].upper()]\n",
    "    \n",
    "    if model_key in models:\n",
    "        current_model = models[model_key]\n",
    "    else:\n",
    "        current_model = create_model(window_length=n_window)\n",
    "        models[model_key] = current_model\n",
    "    \n",
    "    model_category_series = datasets[model_key]\n",
    "    scaler = fit_full_category(model_category_series, current_model, window_length=n_window, batch_size=16, nb_epoch=20)\n",
    "    \n",
    "    scalers[model_key] = scaler\n",
    "    models[model_key] = current_model\n",
    "    #assert False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Write models and scalers to files\n",
    "NB! set the batch identificator to whatever is going on at the moment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "model_batch_identificator = '150518/'\n",
    "models_folder = './models/' + model_batch_identificator\n",
    "scalers_folder = './scalers/' + model_batch_identificator\n",
    "\n",
    "if not os.path.exists(models_folder):\n",
    "    os.makedirs(models_folder)\n",
    "\n",
    "for model_callsign, model in models.items():\n",
    "    model.save(models_folder + model_callsign + '.h5')\n",
    "    \n",
    "if not os.path.exists(scalers_folder):\n",
    "    os.makedirs(scalers_folder)\n",
    "\n",
    "for scaler_callsign, scaler in scalers.items():\n",
    "    joblib.dump(scaler, scalers_folder + scaler_callsign + '.pkl') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SANITY IS FOR THE WEAK! (Read models and scalers from files)\n",
    "NB! set the batch identificator to whatever is going on at the moment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "model_batch_identificator = '150518/'\n",
    "\n",
    "models_folder = './models/' + model_batch_identificator\n",
    "scalers_folder = './scalers/' + model_batch_identificator\n",
    "\n",
    "model_filenames = os.listdir(models_folder)\n",
    "scaler_filenames = os.listdir(scalers_folder)\n",
    "\n",
    "# create a models dict if it doesn't exist and create other required data objects \n",
    "if 'models' not in globals() and 'scalers' not in globals():\n",
    "    models = {}\n",
    "    scalers = {}\n",
    "    horizon_lengths = {\"H\" : 48, \"D\" : 14, \"W\" : 13, \"M\" : 18, \"Q\" : 8, \"Y\" : 6}\n",
    "    window_lengths = {\"H\" : 96, \"D\" : 28, \"W\" : 26, \"M\" : 36, \"Q\" : 16, \"Y\" : 12}\n",
    "\n",
    "    filenames = os.listdir(\"./data/cut/10000/train/\")\n",
    "    #filenames = [\"Hourly.csv\"]\n",
    "    m4_info = pd.read_csv('./data/M4-info.csv')\n",
    "\n",
    "    results_frame = pd.DataFrame()\n",
    "    test_frame = pd.DataFrame()\n",
    "\n",
    "    for model_file in model_filenames:\n",
    "        models[model_file.split(\".\")[0]] = load_model(models_folder + model_file)\n",
    "    \n",
    "    for scaler_file in scaler_filenames:\n",
    "        scalers[scaler_file.split(\".\")[0]] = joblib.load(scalers_folder + scaler_file) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loopy predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1c3cf761284442b9a2f3ca089b1d90aa"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "for file in filenames:\n",
    "    train_set = pd.read_csv('./data/cut/10000/train/' + file)\n",
    "    test_set = pd.read_csv('./data/cut/10000/test/' + file)\n",
    "    \n",
    "    # Go through all the time series in the scope \n",
    "    for i in tnrange(1, train_set.shape[0], desc=file):\n",
    "        series_name = train_set.iloc[i, 1]\n",
    "        series_info = m4_info.loc[m4_info['M4id'] == series_name]\n",
    "        \n",
    "        category_name = series_info['category'].values[0].lower()\n",
    "        scope_name = series_info['SP'].values[0].lower()\n",
    "        model_key = scope_name + \"_\" + category_name \n",
    "        \n",
    "        model = models[model_key]\n",
    "        scaler = scalers[model_key]\n",
    "        \n",
    "        n_predictions = horizon_lengths[series_name[0].upper()]\n",
    "        n_window = window_lengths[series_name[0].upper()]\n",
    "        \n",
    "        series = train_set.iloc[i, 2:].dropna()\n",
    "        test_series = test_set.iloc[i, 1:].tolist()\n",
    "        test_series.insert(0, series_name)\n",
    "        \n",
    "        pred = predict_from_model(series, model, scaler, n_predictions, window_length=n_window)\n",
    "        pred.insert(0, series_name)\n",
    "        \n",
    "        results_frame = results_frame.append(pd.Series(pred), ignore_index=True)\n",
    "        test_frame = test_frame.append(pd.Series(test_series), ignore_index=True)   \n",
    "        #assert False\n",
    "    #assert False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write separate results into .csv files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "hourly_frame = results_frame[results_frame[0].str.contains(\"H\")] \n",
    "hourly_frame = hourly_frame.dropna(axis=1, how='all')\n",
    "hourly_frame.to_csv(\"./results/h_results.csv\", index=False)\n",
    "\n",
    "daily_frame = results_frame[results_frame[0].str.contains(\"D\")]\n",
    "daily_frame = daily_frame.dropna(axis=1, how='all')\n",
    "daily_frame.to_csv(\"./results/d_results.csv\", index=False)\n",
    "\n",
    "weekly_frame = results_frame[results_frame[0].str.contains(\"W\")]\n",
    "weekly_frame = weekly_frame.dropna(axis=1, how='all')\n",
    "weekly_frame.to_csv(\"./results/w_results.csv\", index=False)\n",
    "\n",
    "monthly_frame = results_frame[results_frame[0].str.contains(\"M\")]\n",
    "monthly_frame = monthly_frame.dropna(axis=1, how='all')\n",
    "monthly_frame.to_csv(\"./results/m_results.csv\", index=False)\n",
    "\n",
    "quarterly_frame = results_frame[results_frame[0].str.contains(\"Q\")]\n",
    "quarterly_frame = quarterly_frame.dropna(axis=1, how='all')\n",
    "quarterly_frame.to_csv(\"./results/q_results.csv\", index=False)\n",
    "\n",
    "yearly_frame = results_frame[results_frame[0].str.contains(\"Y\")]\n",
    "yearly_frame = yearly_frame.dropna(axis=1, how='all')\n",
    "yearly_frame.to_csv(\"./results/y_results.csv\", index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write all the resulting data frame to .csv."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "results_frame.to_csv(\"./results/all_results_seq.csv\", index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Printing out a single prediction, if one so chooses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test RMSE: 17821.572\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAD8CAYAAACcjGjIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x28d6382a5c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "rmse = np.sqrt(mean_squared_error(test_frame.iloc[0, 1:], results_frame.iloc[0, 1:]))\n",
    "print('Test RMSE: %.3f' % rmse)\n",
    "# line plot of observed vs predicted\n",
    "plt.plot(test_frame.iloc[0, 1:], label=\"Test data\")\n",
    "plt.plot(results_frame.iloc[0, 1:], label=\"Predictions\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "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.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}