CNN_Text.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "CNN_Text.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/notmanan/Depression-Detection-Through-Multi-Modal-Data/blob/master/CNN_Text.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fmWEz6EMM-GR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "import nltk\n",
        "nltk.download('stopwords')\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from gensim.models.keyedvectors import KeyedVectors\n",
        "import gc\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Conv2D\n",
        "from keras.layers import MaxPooling2D\n",
        "from keras.layers import Flatten\n",
        "from keras.layers import Dense\n",
        "from smart_open import open\n",
        "from nltk.corpus import stopwords\n",
        "from sklearn.metrics import classification_report\n",
        "from keras.layers import Dropout\n",
        "from matplotlib import pyplot as plt\n",
        "from sklearn.metrics import classification_report"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fq9YEtsaDFgi",
        "colab_type": "text"
      },
      "source": [
        "# Preparing Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HMI6yuraNelr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dataset1 = np.array(pd.read_csv('/content/drive/My Drive/MCA Dataset/dev_split_Depression_AVEC2017.csv',delimiter=',',encoding='utf-8'))[:, 0:2]\n",
        "dataset2 = np.array(pd.read_csv('/content/drive/My Drive/MCA Dataset/full_test_split.csv',delimiter=',',encoding='utf-8'))[:, 0:2]\n",
        "dataset3 = np.array(pd.read_csv('/content/drive/My Drive/MCA Dataset/train_split_Depression_AVEC2017.csv',delimiter=',',encoding='utf-8'))[:, 0:2]\n",
        "\n",
        "dataset = np.concatenate((dataset1, np.concatenate((dataset2, dataset3))))\n",
        "\n",
        "countPos = 0\n",
        "\n",
        "def checkPosNeg(dataset, index):\n",
        "    for i in range(0, len(dataset)):\n",
        "        if(dataset[i][0] == index):\n",
        "            return dataset[i][1]\n",
        "    return 0\n",
        "\n",
        "Data = []\n",
        "Y = []\n",
        "\n",
        "countPos = 0\n",
        "index = -1\n",
        "Data_test = []\n",
        "Y_test = []\n",
        "for i in range(0, len(dataset3)):\n",
        "    val = checkPosNeg(dataset, dataset3[i][0])\n",
        "    Y.append(val)\n",
        "    try:\n",
        "      fileName = \"/content/drive/My Drive/MCA Dataset/train_data/\" + str(int(dataset3[i][0])) + \"_TRANSCRIPT.csv\"\n",
        "      Data.append(np.array(pd.read_csv(fileName,delimiter='\\t',encoding='utf-8', engine='python'))[:, 2:4])\n",
        "    except Exception as e:\n",
        "      # print(e)\n",
        "\n",
        "\n",
        "for i in range(0, len(dataset1)):\n",
        "    val = checkPosNeg(dataset, dataset1[i][0])\n",
        "    Y.append(val)\n",
        "    try:\n",
        "      fileName = \"/content/drive/My Drive/MCA Dataset/dev_data/\" + str(int(dataset1[i][0])) + \"_TRANSCRIPT.csv\"\n",
        "      Data.append(np.array(pd.read_csv(fileName,delimiter='\\t',encoding='utf-8', engine='python'))[:, 2:4])\n",
        "    except Exception as e:\n",
        "      # print(e)\n",
        "for i in range(0, len(dataset2)):\n",
        "    Y_test.append(checkPosNeg(dataset, dataset2[i][0]))\n",
        "    try:\n",
        "      fileName = \"/content/drive/My Drive/MCA Dataset/test_data/\" + str(int(dataset2[i][0])) + \"_TRANSCRIPT.csv\"\n",
        "      Data_test.append(np.array(pd.read_csv(fileName,delimiter='\\t',encoding='utf-8', engine='python'))[:, 2:4])\n",
        "    except Exception as e:\n",
        "      # print(e)\n",
        "\n",
        "    \n",
        "Y = np.array(Y)\n",
        "Data2 = []\n",
        "\n",
        "Data2_test = []\n",
        "Y_test = np.array(Y_test)\n",
        "\n",
        "for i in range(0, len(Data)):\n",
        "    script = []\n",
        "    for k in range(1, len(Data[i])):\n",
        "        if(Data[i][k][0] == \"Participant\"):\n",
        "            script.append(Data[i][k][1])\n",
        "    Data2.append(script)\n",
        "    \n",
        "for i in range(0, len(Data_test)):\n",
        "    script = []\n",
        "    for k in range(1, len(Data_test[i])):\n",
        "        if(Data_test[i][k][0] == \"Participant\"):\n",
        "            script.append(Data_test[i][k][1])\n",
        "    Data2_test.append(script)\n",
        "\n",
        "Data = []\n",
        "Data_test = []\n",
        "gc.collect()        \n",
        "Data2 = np.array(Data2)\n",
        "Data2_test = np.array(Data2_test)\n",
        "\n",
        "model = KeyedVectors.load_word2vec_format('/content/drive/My Drive/Copy of GoogleNews-vectors-negative300.bin', binary=True)\n",
        "stop_words = set(stopwords.words('english'))\n",
        "\n",
        "\n",
        "def Thresholding(Y_pred, threshold):\n",
        "  Y_pred2 = []\n",
        "  for i in range(len(Y_pred)):\n",
        "    if(Y_pred[i] < threshold):\n",
        "      Y_pred2.append(0)\n",
        "    else:\n",
        "      Y_pred2.append(1)\n",
        "\n",
        "  return np.array(Y_pred2)\n",
        "\n",
        "def remove_StopWords(sentence):\n",
        "    filtered_sentence = [] \n",
        "    for w in sentence: \n",
        "        if w not in stop_words: \n",
        "            filtered_sentence.append(w)\n",
        "    \n",
        "    return filtered_sentence\n",
        "\n",
        "def checkAcc(Y_pred, Y_test):\n",
        "    correct = 0\n",
        "    for i in range(len(Y_pred)):\n",
        "        if(Y_pred[i] == Y_test[i]):\n",
        "            correct+=1\n",
        "    \n",
        "    return float(correct)/len(Y_pred)\n",
        "\n",
        "def upsample(X_train,Y_train):\n",
        "  X_train_0 = X_train[Y_train==0]\n",
        "  X_train_1 = X_train[Y_train==1]\n",
        "\n",
        "  Y_train_1 = Y_train[Y_train==1]\n",
        "  size = X_train_0.shape[0] - X_train_1.shape[0]\n",
        "  X = []\n",
        "  Y = []\n",
        "  X_train = list(X_train)\n",
        "  Y_train = list(Y_train)\n",
        "  while(size>0):\n",
        "    size -= 1\n",
        "    index = np.random.randint(0,X_train_1.shape[0]-1)\n",
        "    leave_index = np.random.randint(0,len(X_train)-1)\n",
        "    X_add = X_train_1[index]\n",
        "    X_leave = X_train[leave_index]\n",
        "\n",
        "    Y_add = Y_train_1[index]\n",
        "    Y_leave = Y_train[leave_index]\n",
        "\n",
        "    X_train[leave_index] = X_add\n",
        "    X_train.append(X_leave)\n",
        "\n",
        "    Y_train[leave_index] = Y_add\n",
        "    Y_train.append(Y_leave)\n",
        "\n",
        "\n",
        "  X_train = np.array(X_train)\n",
        "  Y_train = np.array(Y_train)\n",
        "  return X_train,Y_train\n",
        "\n",
        "\n",
        "max_num_words = 20\n",
        "max_num_sentence = 250\n",
        "\n",
        "#train_data\n",
        "finalMatrix = np.zeros((Data2.shape[0], max_num_sentence, max_num_words, 300))\n",
        "max_length_sent = 0\n",
        "sent = \"\"\n",
        "for k in range(Data2.shape[0]):\n",
        "    if(max_length_sent < len(Data2[k])):\n",
        "      max_length_sent = len(Data2[k])\n",
        "      sent = Data2[k]\n",
        "    for i in range(min(max_num_sentence, len(Data2[k]))):\n",
        "    \ttry:\n",
        "    \t  sentence = Data2[k][i].split(\" \")\n",
        "    \texcept:\n",
        "    \t  continue\n",
        "    \tsentence = remove_StopWords(sentence)\n",
        "    \tfor j in range(min(max_num_words, len(sentence))):\n",
        "    \t\ttry:\n",
        "    \t\t  word = sentence[j]\n",
        "    \t\t  # print(\"Before\", word)\n",
        "    \t\t  if(word[0] == '<'):\n",
        "    \t\t    if(word.find('>')!=-1):\n",
        "    \t\t      word = word[1:-1]\n",
        "    \t\t    else:\n",
        "    \t\t      word = word[1:]\n",
        "    \t\t  else:\n",
        "    \t\t    if(word.find('>')!=-1):\n",
        "    \t\t      word = word[0:-1]\n",
        "    \t\t  finalMatrix[k][i][j] = np.array(model[word])\n",
        "    \t\texcept Exception as e:\n",
        "    \t\t\tcontinue\n",
        "\n",
        "#Test_data\n",
        "max_length_sent = 0\n",
        "finalMatrix_test = np.zeros((Data2_test.shape[0], max_num_sentence, max_num_words, 300))\n",
        "# print(finalMatrix_test.shape)\n",
        "for k in range(Data2_test.shape[0]):\n",
        "    if(max_length_sent < len(Data2_test[k])):\n",
        "      max_length_sent = len(Data2_test[k])\n",
        "      sent = Data2_test[k]\n",
        "    for i in range(min(max_num_sentence, len(Data2_test[k]))):\n",
        "    \ttry:\n",
        "    \t  sentence = Data2_test[k][i].split(\" \")\n",
        "    \texcept:\n",
        "    \t  continue\n",
        "    \tsentence = remove_StopWords(sentence)\n",
        "    \tfor j in range(min(max_num_words, len(sentence))):\n",
        "    \t\ttry:\n",
        "    \t\t  word = sentence[j]\n",
        "    \t\t  if(word[0] == '<'):\n",
        "    \t\t    if(word.find('>')!=-1):\n",
        "    \t\t      word = word[1:-1]\n",
        "    \t\t    else:\n",
        "    \t\t      word = word[1:]\n",
        "    \t\t  else:\n",
        "    \t\t    if(word.find('>')!=-1):\n",
        "    \t\t      word = word[0:-1]\n",
        "    \t\t  finalMatrix_test[k][i][j] = np.array(model[word])\n",
        "    \t\texcept Exception as e:\n",
        "    \t\t\tcontinue\n",
        "\n",
        "Data2 = []\n",
        "Data2_test = []\n",
        "model = []\n",
        "stop_words = []\n",
        "gc.collect()\n",
        "\n",
        "\n",
        "finalMatrix, Y = upsample(finalMatrix,Y)\n",
        "finalMatrix_test, Y_test = upsample(finalMatrix_test,Y_test)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bClgCLgbC-e9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class CNN_Text:\n",
        "  def __init__(self):\n",
        "    # Initialising the CNN\n",
        "    classifier = Sequential()\n",
        "    # Step 1 - Convolution\n",
        "    classifier.add(Conv2D(150, (1, 5), input_shape = (finalMatrix.shape[1], finalMatrix.shape[2], finalMatrix.shape[3]), activation = 'relu', data_format=\"channels_last\"))\n",
        "    # Step 2 - Pooling\n",
        "    classifier.add(MaxPooling2D(pool_size = (1, 3)))\n",
        "    # Adding a second convolutional layer\n",
        "    classifier.add(Conv2D(75, (1, 3), activation = 'relu', data_format=\"channels_last\"))\n",
        "    classifier.add(MaxPooling2D(pool_size = (1, 2)))\n",
        "    # Step 3 - Flattening\n",
        "    classifier.add(Flatten())\n",
        "    # Step 4 - Full connection\n",
        "    classifier.add(Dense(units = 128, activation = 'relu'))\n",
        "    classifier.add(Dense(units = 1, activation = 'sigmoid'))\n",
        "    # Compiling the CNN\n",
        "    classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])\n",
        "    self.classifier = classifier\n",
        "\n",
        "  def fitModel(self, X, Y, epoch = 10):\n",
        "    class_weight = {0: 0.5, 1: 0.6}\n",
        "    self.classifer.fit(X, Y, epochs = epoch, class_weight=class_weight)\n",
        "  \n",
        "  def predictModel(self, X):\n",
        "    return Thresholding(classifier.predict(X), 0.5)\n",
        "  \n",
        "model = CNN_Text()\n",
        "model.fitModel(finalMatrix, Y, 10)\n",
        "Y_Pred = model.predictModel(finalMatrix_test)\n",
        "print(classification_report(Y_test, Y_Pred))"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}