00_core.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp core"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGNN\n",
    "\n",
    "> Implementation of Self-Governing Neural Networks for speech act classification\n",
    "\n",
    "## Implementation of the [SGNN paper](https://www.aclweb.org/anthology/D19-1402.pdf) for speech act classification.\n",
    "This repository is inspired by Guillaume Chevalier's [implementation](https://github.com/guillaume-chevalier/SGNN-Self-Governing-Neural-Networks-Projection-Layer), as well as his [discussion](https://github.com/guillaume-chevalier/SGNN-Self-Governing-Neural-Networks-Projection-Layer/issues/1) with [Sava Kalbachou](https://github.com/thinline).\n",
    "This version implements some things differently from Guillaume's code, in an attempt to resemble the paper more, and extends beyond the projection layer all the way to a fully trainable network.\n",
    "\n",
    "The network is trained to classify the [SwDA corpus](https://web.stanford.edu/~jurafsky/ws97/) utterances according to their speech act. The corpus was was pre-processed using Cristopher Pott's [project](https://github.com/cgpotts/swda/) related to it. To follow Lee & Dernoncourt SwDA data split, as in the SGNN paper, we added [adequate functionality](https://github.com/glicerico/swda/blob/data_split/create_sets.py) in our [branch](https://github.com/glicerico/swda/tree/data_split) of that repo. The pre-processed data is included in the [`data`](data) folder for repeateability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "from nbdev.showdoc import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Required modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:516: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:517: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:518: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:519: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:520: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorflow/python/framework/dtypes.py:525: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:541: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:542: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:543: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:544: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:545: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\n",
      "/home/andres/src/miniconda3/envs/speechActs/lib/python3.7/site-packages/tensorboard/compat/tensorflow_stub/dtypes.py:550: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n",
      "  np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
     ]
    }
   ],
   "source": [
    "#export\n",
    "import functools\n",
    "import random as rand\n",
    "import re\n",
    "\n",
    "from livelossplot import PlotLossesKerasTF\n",
    "from nearpy.hashes import RandomBinaryProjections\n",
    "from nltk.util import skipgrams\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import scipy.sparse as sp\n",
    "from sklearn.base import BaseEstimator\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.pipeline import Pipeline, FeatureUnion\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import data from file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def import_data(filepath):\n",
    "    \"\"\"\n",
    "    Imports data from file and removes empty entries\n",
    "    :param filepath:  Path to file with SwDa utterances in format \"ActTag,Text\"\n",
    "    :return:          pandas dataframe with the data\n",
    "    \"\"\"\n",
    "    data = pd.read_csv(filepath)\n",
    "    data = data.dropna(axis=0)  # Drop rows with NA values\n",
    "    \n",
    "    return data\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocess data, and divide it in train, validation and test sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export    \n",
    "def preprocess_data(data, lowercase=False, clean=False, remove_continuations=True):\n",
    "    \"\"\"\n",
    "    Preprocess the data according to parameters. \n",
    "    Divides the data into training, validation and test sets.\n",
    "    \n",
    "    :param data:  Pandas dataframe imported by `import_data`\n",
    "    Optional:\n",
    "    :param lowercase:  Convert all text to lowercase\n",
    "    :param clean:  Remove punctuation marks and non-verbal utterances\n",
    "    :param remove_continuations:  Remove utterances with act tag \"+\"\n",
    "    \n",
    "    :return:  Pandas series with training, validation and test tags and utterances\n",
    "    \"\"\"\n",
    "    if lowercase:\n",
    "        data['Text'] = data['Text'].str.lower()\n",
    "    if clean:\n",
    "        # Remove punctuation\n",
    "        data['Text'] = [re.sub('[(|)|#|.]', '', line) for line in data['Text']]\n",
    "        # Remove dashes and words in angle brackets (e.g. \"<Laughter>\")\n",
    "        data['Text'] = [re.sub('\\W-+\\W|<\\w+>', ' ', line) for line in data['Text']]\n",
    "    if remove_continuations:\n",
    "        data = data[~(data.DamslActTag == '+')]\n",
    "    \n",
    "    # Remove extra spaces\n",
    "    data['Text'] = [re.sub('\\s+', ' ', line) for line in data['Text']]\n",
    "    data = data[~(data.Text == ' ')]  # Remove data rows that end up empty after cleaning\n",
    "                            \n",
    "    X, y = data.Text, data.DamslActTag\n",
    "                            \n",
    "    return X, y\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transform RandomBinaryProjections to transformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class Transformer_RBP(BaseEstimator, RandomBinaryProjections):\n",
    "    \"\"\"\n",
    "    Class that modifies RandomBinaryProjections to use as an sklearn transformer\n",
    "    \"\"\"\n",
    "    rand_seed = None  # Declare it as class variable\n",
    "    def __init__(self, hash_name='hasher', projection_count=1, rand_seed=None):\n",
    "        RandomBinaryProjections.__init__(self, hash_name, projection_count, rand_seed=rand_seed)\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        self.rand = np.random.RandomState(self.rand_seed)  # rand seed after param setting\n",
    "        self.reset(X.shape[1])\n",
    "        \n",
    "    def transform(self, X):\n",
    "        return self.hash_vector(X)\n",
    "\n",
    "    def fit_transform(self, X, y):\n",
    "        self.fit(X, y)\n",
    "        return self.transform(X)\n",
    "    \n",
    "    def hash_vector(self, v, querying=False):\n",
    "        \"\"\"\n",
    "        Hashes the vector and returns the binary bucket key as string.\n",
    "        \"\"\"\n",
    "        if sp.issparse(v):\n",
    "            # If vector is sparse, make sure we have the CSR representation\n",
    "            # of the projection matrix\n",
    "            if self.normals_csr is None:\n",
    "                self.normals_csr = sp.csr_matrix(self.normals)\n",
    "            # Make sure that we are using CSR format for multiplication\n",
    "            if not sp.isspmatrix_csr(v):\n",
    "                v = sp.csr_matrix(v)\n",
    "            # Project vector onto all hyperplane normals\n",
    "            # projection = self.normals_csr.dot(v)\n",
    "            projection = v.dot(sp.csr_matrix.transpose(self.normals_csr))\n",
    "        else:\n",
    "            # Project vector onto all hyperplane normals\n",
    "            projection = np.dot(v, np.matrix.transpose(self.normals))\n",
    "        # Return binary key\n",
    "        return projection > 0\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create input layer projections\n",
    "This is the main contribution of the SGNN paper, and the implementation is inspired by Guillaume Chevalier's [implementation](https://github.com/guillaume-chevalier/SGNN-Self-Governing-Neural-Networks-Projection-Layer), as well as his [discussion](https://github.com/guillaume-chevalier/SGNN-Self-Governing-Neural-Networks-Projection-Layer/issues/1) with [Sava Kalbachou](https://github.com/thinline)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def build_input_layer(T=80, d=14):\n",
    "    \"\"\"\n",
    "    Transformer to build the input layer, in SGNN style.\n",
    "    Uses nltk skipgrams, and several Transformer_RBP layers as elements of the SGNN pipeline.\n",
    "    \"\"\"\n",
    "    # T=80 projections for each of dimension d=14: 80 * 14 = 1120-dimensionnal word projections\n",
    "\n",
    "    # Wrap skipgrams to use with CountVectorizer\n",
    "    skipper = functools.partial(skipgrams, n=3, k=2) # 2-skip-3-grams\n",
    "    # CountVectorizer params\n",
    "    char_term_frequency_params = {\n",
    "        'char_term_frequency__analyzer': skipper,\n",
    "        'char_term_frequency__min_df': 3,\n",
    "        'char_term_frequency__max_df': 0.9,\n",
    "        'char_term_frequency__max_features': int(1e7),\n",
    "    }\n",
    "\n",
    "    # Transformer_RBP params\n",
    "    rand_seeds = [rand.randint(0, T*100) for i in range(T)] # Need a different repeatable seed for each hasher\n",
    "    hashing_feature_union_params = {\n",
    "        **{'union__random_binary_projection_hasher_{}__projection_count'.format(t): d\n",
    "           for t in range(T)\n",
    "        },\n",
    "        **{'union__random_binary_projection_hasher_{}__hash_name'.format(t): 'hasher' + str(t)\n",
    "           for t in range(T)\n",
    "        },\n",
    "        **{'union__random_binary_projection_hasher_{}__rand_seed'.format(t): rand_seeds[t]  # only AFTER hashing.\n",
    "           for t in range(T)\n",
    "        }\n",
    "    }\n",
    "\n",
    "    # Pipeline to create input layer\n",
    "    preprocessor = Pipeline([\n",
    "        (\"char_term_frequency\", CountVectorizer()),\n",
    "        ('union', FeatureUnion([\n",
    "            ('random_binary_projection_hasher_{}'.format(t), Transformer_RBP())\n",
    "            for t in range(T)\n",
    "        ]))\n",
    "    ])\n",
    "    \n",
    "    params = dict()\n",
    "    params.update(char_term_frequency_params)\n",
    "    params.update(hashing_feature_union_params)\n",
    "    preprocessor.set_params(**params)\n",
    "    return preprocessor\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create keras model\n",
    "Following the SGNN paper's architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def build_keras_model(train_labels):\n",
    "    \"\"\"\n",
    "    Build keras model, with two hidden layers as the SGNN paper.\n",
    "    \"\"\"\n",
    "    model = keras.Sequential()\n",
    "#     model.add(keras.layers.Dropout(0.25, input_shape=(1120,)))\n",
    "#     model.add(keras.layers.Dense(256, activation=tf.nn.relu))\n",
    "    model.add(keras.layers.Dense(256, activation=tf.nn.sigmoid, input_shape=(1120,)))\n",
    "    model.add(keras.layers.Dropout(0.25))\n",
    "#     model.add(keras.layers.Dense(256, activation=tf.nn.relu))\n",
    "#     model.add(keras.layers.Dropout(0.25))\n",
    "    model.add(keras.layers.Dense(256, activation=tf.nn.sigmoid))\n",
    "    model.add(keras.layers.Dropout(0.25))\n",
    "    model.add(keras.layers.Dense(train_labels.shape[1], activation=tf.nn.softmax))\n",
    "\n",
    "    # Cosine annealing decay\n",
    "    lr_schedule = keras.experimental.CosineDecay(0.025, decay_steps=20000)\n",
    "    # SGD optimizer with Nesterov momentum\n",
    "    opt = keras.optimizers.SGD(nesterov=True, learning_rate=lr_schedule)\n",
    "#     opt = keras.optimizers.SGD(nesterov=True)\n",
    "    model.compile(loss='categorical_crossentropy',\n",
    "                  optimizer=opt,\n",
    "                  metrics=['accuracy'])\n",
    "\n",
    "    return model\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Main process, putting together previous functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "def main(lowercase=False, clean=False, remove_continuations=True):\n",
    "    data_train = import_data(TRAIN_FILEPATH)\n",
    "    data_valid = import_data(VALID_FILEPATH)\n",
    "    data_test = import_data(TEST_FILEPATH)\n",
    "    X_train, y_train = preprocess_data(data_train, lowercase=lowercase, clean=clean,\n",
    "                                           remove_continuations=remove_continuations)\n",
    "    X_valid, y_valid = preprocess_data(data_valid, lowercase=lowercase, clean=clean,\n",
    "                                           remove_continuations=remove_continuations)\n",
    "    X_test, y_test = preprocess_data(data_test, lowercase=lowercase, clean=clean,\n",
    "                                         remove_continuations=remove_continuations)\n",
    "    \n",
    "    # Convert labels to categories\n",
    "    le = LabelEncoder()\n",
    "    y_train = le.fit_transform(y_train)\n",
    "    y_valid = le.transform(y_valid)\n",
    "    y_test = le.transform(y_test)\n",
    "    \n",
    "    # Convert categories to one-hot-encodings, as needed by keras\n",
    "    train_labels = keras.utils.to_categorical(y_train)\n",
    "    valid_labels = keras.utils.to_categorical(y_valid)\n",
    "    test_labels = keras.utils.to_categorical(y_test)\n",
    "    \n",
    "    # Pass text sets through input layer\n",
    "    input_layer = build_input_layer()\n",
    "    train_features = input_layer.fit_transform(X_train)\n",
    "    valid_features = input_layer.transform(X_valid)\n",
    "    test_features = input_layer.transform(X_test)\n",
    "    \n",
    "    # Define EarlyStopping and loss visualization\n",
    "    keras_callbacks = [tf.keras.callbacks.EarlyStopping(monitor='loss', patience=3, \n",
    "                                                        restore_best_weights=True),\n",
    "                       PlotLossesKerasTF()]\n",
    "    \n",
    "    # Fit and evaluate NN\n",
    "    keras_model = build_keras_model(train_labels)\n",
    "    keras_model.fit(train_features, train_labels, epochs=EPOCHS, \n",
    "                    batch_size=BATCH_SIZE, shuffle=True,\n",
    "                    validation_data=(valid_features, valid_labels),\n",
    "                    callbacks=keras_callbacks\n",
    "                   )\n",
    "#     keras_model.evaluate(test_features, test_labels)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "# EPOCHS = 1000\n",
    "EPOCHS = 1\n",
    "BATCH_SIZE = 100\n",
    "LOWERCASE=True\n",
    "CLEAN=True\n",
    "REMOVE_CONTINUATIONS=True\n",
    "# REPO_PATH = \"<PATH-TO-SGNN-REPO>\"\n",
    "REPO_PATH=\"\"\n",
    "TRAIN_FILEPATH = REPO_PATH + \"data/train-acttags-and-text.csv\"\n",
    "VALID_FILEPATH = REPO_PATH + \"data/valid-acttags-and-text.csv\"\n",
    "TEST_FILEPATH = REPO_PATH + \"data/test-acttags-and-text.csv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy\n",
      "\ttraining         \t (min:    0.527, max:    0.630, cur:    0.630)\n",
      "\tvalidation       \t (min:    0.590, max:    0.641, cur:    0.641)\n",
      "Loss\n",
      "\ttraining         \t (min:    1.268, max:    1.771, cur:    1.268)\n",
      "\tvalidation       \t (min:    1.228, max:    1.514, cur:    1.228)\n",
      "174677/174677 [==============================] - 7s 39us/sample - loss: 1.2678 - acc: 0.6302 - val_loss: 1.2276 - val_acc: 0.6406\n",
      "Epoch 10/1000\n",
      "167400/174677 [===========================>..] - ETA: 0s - loss: 1.2641 - acc: 0.6311"
     ]
    }
   ],
   "source": [
    "#hide\n",
    "main(lowercase=LOWERCASE, clean=CLEAN, remove_continuations=REMOVE_CONTINUATIONS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}