RNN for next event prediction.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "============================================================\n",
      " SimpleRNN for demographic sequences and features            \n",
      "============================================================\n",
      "Training & evaluation 1 : accuracy = 0.928 time = 13.32\n",
      "Training & evaluation 2 : accuracy = 0.930 time = 13.39\n",
      "Training & evaluation 3 : accuracy = 0.929 time = 13.33\n",
      "Training & evaluation 4 : accuracy = 0.921 time = 13.41\n",
      "Training & evaluation 5 : accuracy = 0.932 time = 13.36\n",
      "Training & evaluation 6 : accuracy = 0.934 time = 13.93\n",
      "Training & evaluation 7 : accuracy = 0.937 time = 13.45\n",
      "Training & evaluation 8 : accuracy = 0.916 time = 13.55\n",
      "Training & evaluation 9 : accuracy = 0.928 time = 13.52\n",
      "Training & evaluation 10 : accuracy = 0.916 time = 13.38\n",
      "\n",
      "Model training & evaluation time (mean): 13.50\n",
      "Accuracy (mean): 0.927 , Variance: 0.000049 , Standard deviation: 0.007000\n",
      "==========================================================================\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "from sklearn.utils import shuffle\n",
    "from tensorflow.keras.backend import backend\n",
    "from tensorflow.keras.models import *\n",
    "from tensorflow.keras.layers import * \n",
    "\n",
    "import tensorflow as tf\n",
    "gpus = tf.config.experimental.list_physical_devices('GPU')\n",
    "tf.config.experimental.set_memory_growth(gpus[0], True)\n",
    "#print(gpus)\n",
    "\n",
    "print (\"============================================================\")\n",
    "print (\" SimpleRNN for demographic sequences and features           \")\n",
    "print (\"============================================================\")\n",
    "\n",
    "\n",
    "start_time = time.time()\n",
    "time_01 = time.time()\n",
    "acc_list = []\n",
    "\n",
    "df = pd.read_excel(\"table.xlsx\")\n",
    "df.dropna(inplace = True)   # remove empty (NaN) lines\n",
    "\n",
    "n = 10\n",
    "for ii in range(1, n+1):\n",
    "    \n",
    "    time_02 = time.time()\n",
    "    \n",
    "    df = shuffle(df) \n",
    "\n",
    "    size = df.shape[0]\n",
    "    t = int(size * 0.8)         # train part size\n",
    "\n",
    "    x = df.values[:size, 0:7]\n",
    "    y = np.empty(size, dtype=str)\n",
    "\n",
    "    for i in range(x.shape[0]):\n",
    "        y[i] = x[i, 0][-1]\n",
    "        x[i, 0] = x[i, 0][:-1]\n",
    "\n",
    "    X = np.empty((x.shape[0], x.shape[1]), dtype='int32')\n",
    "\n",
    "    for d in range(x.shape[1]):        \n",
    "        xs = list(set(x[:, d]))\n",
    "\n",
    "        xd = {xs[i]: i for i in range(len(xs))}\n",
    "        for l in range(x.shape[0]):\n",
    "            X[l][d] = xd[x[l][d]]\n",
    "\n",
    "\n",
    "    XF_train = X[0:t, 1:]           # train features\n",
    "    XF_test  = X[t:size, 1:]        # test features\n",
    "\n",
    "    yn = np.empty((size), dtype='int32')\n",
    "\n",
    "    ys = list(set(y[:]))\n",
    "    yd = {ys[i]: i for i in range(len(ys))}\n",
    "    for l in range(len(yn)):\n",
    "        yn[l] = yd[y[l]]\n",
    "\n",
    "    y_train = yn[0:t]\n",
    "    y_test  = yn[t:size]\n",
    "\n",
    "    # all unique characters to the set\n",
    "    events = set()\n",
    "    for seq in x[:, 0]:\n",
    "        for event in seq:\n",
    "            events.add(event)\n",
    "\n",
    "    events = list(events)\n",
    "    event_to_id = {t:i+1 for i,t in enumerate(events)}\n",
    "\n",
    "    max_seq_len = 7\n",
    "    seq_events_numbered = np.zeros((x.shape[0], max_seq_len), dtype='int32')\n",
    "\n",
    "    for i in range(seq_events_numbered.shape[0]):\n",
    "        for k in range(len(x[i][0])):\n",
    "            seq_events_numbered[i][k] = event_to_id[x[i][0][k]]\n",
    "\n",
    "    S_train = seq_events_numbered[0:t, :]       # train sequences\n",
    "    S_test  = seq_events_numbered[t:size, :]    # test sequences\n",
    "\n",
    "    \n",
    "    features_input = Input(shape=(6,))\n",
    "    features_1     = Dense(100, activation=\"relu\", input_dim=6)(features_input)\n",
    "    features_2     = Dropout(0.1)(features_1)\n",
    "    features_out   = Dense(100, activation=\"relu\")(features_2)\n",
    "\n",
    "    sequences_input = Input(shape=(7,))\n",
    "    sequences_1     = Embedding(input_dim=9, output_dim=200)(sequences_input)\n",
    "    sequences_out   = SimpleRNN(200)(sequences_1)   # SimpleRNN may be replaced by GRU or LSTM\n",
    "\n",
    "    sequences_features_0 = concatenate([features_out, sequences_out])\n",
    "    sequences_features_1 = Dense(300, activation='relu')(sequences_features_0)\n",
    "    sequences_features_2 = Dropout(0.05)(sequences_features_1)\n",
    "    sequences_features_out = Dense(8, activation='softmax')(sequences_features_2)\n",
    "\n",
    "    sequences_features = Model(inputs=[features_input, sequences_input], outputs=sequences_features_out)\n",
    "\n",
    "    sequences_features.compile(loss='sparse_categorical_crossentropy', optimizer='adam',\n",
    "                      metrics=['sparse_categorical_accuracy'])\n",
    "\n",
    "    \n",
    "    sequences_features.fit([XF_train, S_train], y_train, epochs=70, batch_size=100, verbose=0)\n",
    "\n",
    "    score, acc = sequences_features.evaluate([XF_test, S_test], y_test, verbose=0)\n",
    "    acc_list.append(acc)\n",
    "    \n",
    "    print(\"Training & evaluation\", ii, \": accuracy = %0.3f\" % acc, \"time = %0.2f\" % (time.time() - time_02))\n",
    "\n",
    "time_03 = time.time()\n",
    "\n",
    "print (\"\\nModel training & evaluation time (mean): %0.2f\" % ((time_03 - start_time)/n))   \n",
    "print (\"Accuracy (mean): %.3f\" % np.mean((acc_list)), \", Variance: %.6f\" % (np.var(acc_list)), \n",
    "       \", Standard deviation: %.6f\" % (np.std(acc_list)))\n",
    "print (\"==========================================================================\")\n"
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}