as2-model-2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import os,shutil\n",
    "import numpy as np\n",
    "import cv2\n",
    "import pickle\n",
    "import pandas as pd\n",
    "\n",
    "from tqdm import tqdm_notebook\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import f1_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Conv2D, Flatten, BatchNormalization, MaxPooling2D, Dropout, Activation\n",
    "from keras.initializers import glorot_normal\n",
    "from keras.optimizers import Adam\n",
    "from keras.losses import binary_crossentropy\n",
    "from keras.utils import to_categorical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "cur_dir = os.getcwd()\n",
    "\n",
    "dataset_dir = os.path.join(cur_dir,\"Dataset\")\n",
    "\n",
    "labels_dir = os.path.join(dataset_dir,\"labels\")\n",
    "frames_dir = os.path.join(dataset_dir,\"frames\")\n",
    "\n",
    "n_lecs = len(os.listdir(labels_dir))\n",
    "\n",
    "listOfLectures = []\n",
    "\n",
    "for lec in sorted(os.listdir(frames_dir)):\n",
    "    if lec.startswith('.'):\n",
    "        continue\n",
    "    frame_list = []\n",
    "    lec_path = os.path.join(frames_dir,lec)\n",
    "    for frame in sorted(os.listdir(lec_path)):\n",
    "        frame_list.append([os.path.join(lec_path,frame),])\n",
    "    listOfLectures.append(frame_list)\n",
    "\n",
    "\n",
    "lec_num = 0\n",
    "for csv in sorted(os.listdir(labels_dir)):\n",
    "    csv_path = os.path.join(labels_dir,csv)\n",
    "    with open(csv_path,'r') as input:\n",
    "        data = input.read()\n",
    "        data = data.split()\n",
    "        for i in range(len(data)):\n",
    "            listOfLectures[lec_num][i].append(int(data[i]))\n",
    "    lec_num+=1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Window size is the size of window on either side. Using window_size = 2 will cause 5 frames to be stacked for one input example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_data_fast(listOfLectures, resolution, window_size):\n",
    "    X_train = []\n",
    "    Y_train = []\n",
    "    for i in tqdm_notebook(range(len(listOfLectures))):\n",
    "        im_saved = []\n",
    "        for j in tqdm_notebook(range(window_size,len(listOfLectures[i])-window_size)):\n",
    "            if j == window_size:\n",
    "                im_saved = [cv2.resize(cv2.imread(listOfLectures[i][j+k][0], 0), resolution) \n",
    "                       for k in range(-window_size, window_size+1)]\n",
    "            else:\n",
    "                ims = im_saved[1:]\n",
    "                ims.append(cv2.resize(cv2.imread(listOfLectures[i][j+window_size][0], 0), resolution))\n",
    "                im_saved = ims\n",
    "            x = np.stack(im_saved,axis=2)\n",
    "            X_train.append(x)\n",
    "            Y_train.append(listOfLectures[i][j][1])\n",
    "    return X_train, Y_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "resolution = (60,80)\n",
    "window_size = 1\n",
    "X, Y = load_data_fast(listOfLectures, resolution, window_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, Y_train = load_data_fast(listOfLectures, (60, 80))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = np.stack(X_train)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "with open(\"./XY_train_80_60_5.pkl\", \"wb\") as pickle_in:\n",
    "    pickle.dump((X_train, Y_train), pickle_in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"./XY_train_80_60_5.pkl\", \"rb\") as pickle_in:\n",
    "    X_train, Y_train = pickle.load(pickle_in)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "Y_train = to_categorical(Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(28997, 2)\n",
      "(28997, 80, 60, 5)\n"
     ]
    }
   ],
   "source": [
    "print(Y_train.shape)\n",
    "print(X_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, Y_train, Y_test = train_test_split(X_train, Y_train, test_size=0.1, random_state=42, stratify=Y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(26097, 80, 60, 5)\n",
      "(2900, 80, 60, 5)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "print(X_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25117.0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(Y_train[:, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.utils import resample\n",
    "X_train_pos = X_train[Y_train[:, 1] == 1]\n",
    "Y_train_pos = Y_train[Y_train[:, 1] == 1]\n",
    "X_train_ups, Y_train_ups =  resample(X_train_pos, Y_train_pos, \n",
    "                                 replace=True,     # sample with replacement\n",
    "                                 n_samples=25117,    # to match majority class\n",
    "                                 random_state=123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train_final = np.concatenate((X_train[Y_train[:, 1] == 0], X_train_ups), axis=0)\n",
    "Y_train_final = np.concatenate((Y_train[Y_train[:, 1] == 0], Y_train_ups), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(50234, 80, 60, 5)\n",
      "(50234, 2)\n"
     ]
    }
   ],
   "source": [
    "print(X_train_final.shape)\n",
    "print(Y_train_final.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_epochs = 5\n",
    "num_classes = 2\n",
    "# batch_size = 100\n",
    "learning_rate = 0.001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen_model():\n",
    "    model = Sequential()\n",
    "    model.add(Conv2D(64, kernel_size=3, activation='relu', input_shape=(80,60,5), padding='valid'))\n",
    "    model.add(Conv2D(64, kernel_size=3, activation='relu', padding='valid'))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid'))\n",
    "    \n",
    "    model.add(Conv2D(32, kernel_size=3, activation='relu'))\n",
    "    model.add(Conv2D(32, kernel_size=3, activation='relu'))\n",
    "    model.add(BatchNormalization())\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2), strides=None, padding='valid'))\n",
    "    \n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(2, activation='softmax'))\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = gen_model()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "optim = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, amsgrad=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='binary_crossentropy', optimizer=optim, metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 50234 samples, validate on 2900 samples\n",
      "Epoch 1/5\n",
      "50234/50234 [==============================] - 71s 1ms/step - loss: 0.1927 - acc: 0.9288 - val_loss: 0.2700 - val_acc: 0.9145\n",
      "Epoch 2/5\n",
      "50234/50234 [==============================] - 67s 1ms/step - loss: 0.0805 - acc: 0.9775 - val_loss: 0.0807 - val_acc: 0.9790\n",
      "Epoch 3/5\n",
      "50234/50234 [==============================] - 67s 1ms/step - loss: 0.0479 - acc: 0.9875 - val_loss: 0.0823 - val_acc: 0.9769\n",
      "Epoch 4/5\n",
      "50234/50234 [==============================] - 67s 1ms/step - loss: 0.0356 - acc: 0.9905 - val_loss: 0.0669 - val_acc: 0.9828\n",
      "Epoch 5/5\n",
      "50234/50234 [==============================] - 67s 1ms/step - loss: 0.0250 - acc: 0.9937 - val_loss: 0.0998 - val_acc: 0.9721\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7f2ca209e1d0>"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "history = model.fit(X_train_final, Y_train_final, epochs=5, verbose=1, validation_data=(X_test, Y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = model.predict(X_test)\n",
    "preds = np.argmax(preds, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.98      0.99      2791\n",
      "           1       0.59      0.88      0.70       109\n",
      "\n",
      "   micro avg       0.97      0.97      0.97      2900\n",
      "   macro avg       0.79      0.93      0.84      2900\n",
      "weighted avg       0.98      0.97      0.97      2900\n",
      "\n",
      "0.7032967032967032\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(np.argmax(Y_test, axis=1), preds))\n",
    "print(f1_score(np.argmax(Y_test, axis=1), preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save('f1_0.8.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}