NN-Train-and-Test.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initizlizations of Aspect Category System"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Training Sentences with categories: 1708\n",
      "Total Unique Sentences:  2000\n",
      "Total Validation Sentences with categories: 582\n",
      "Total Unique Sentences:  685\n",
      "Total Gold Test set Sentences with categories: 587\n",
      "Total Unique Sentences:  676\n"
     ]
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "import sys\n",
    "import numpy as np\n",
    "import gensim.models\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd   \n",
    "from sklearn.manifold import TSNE\n",
    "from gensim.models.word2vec import Word2Vec\n",
    "from sklearn.preprocessing import scale\n",
    "import logging\n",
    "import random\n",
    "import simplejson as json\n",
    "import src.w2v_utils  as w2v_utils\n",
    "\n",
    "setValidation = True  #to create a validation set or not\n",
    "scaleVectors  = False #to scale word vectors or not\n",
    "skipSections  = True  #to skip sections of codes for fast executions\n",
    "\n",
    "logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s',level=logging.INFO)\n",
    "\n",
    "# As usual, a bit of setup\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "xml_data_files = 'data/xml_files'\n",
    "txt_data_files = 'data/txt_files'\n",
    "csv_data_files = 'data/csv_files'\n",
    "\n",
    "###Training Data###\n",
    "training_Input_File       = '{}/ABSA16_Restaurants_Train_SB1_v2.xml'.format(xml_data_files)\n",
    "training_output_File      = '{}/ABSA16_Restaurants_Train_SB1_v2.txt'.format(txt_data_files)\n",
    "training_Unique_Sentences = '{}/ABSA16_Restaurants_Train_SB1_v2_Unique.txt'.format(txt_data_files)\n",
    "w2v_utils.getTraining_setFile(\"Total Training Sentences with categories:\",training_Input_File, training_output_File)\n",
    "w2v_utils.getSentencesFile(training_Input_File, training_Unique_Sentences)\n",
    "\n",
    "###Validation Data###\n",
    "test_Input_File  = '{}/ABSA15_Restaurants_Test.xml'.format(xml_data_files)\n",
    "test_output_File = '{}/ABSA15_Restaurants_Test.txt'.format(txt_data_files)\n",
    "test_Unique_Sentences = '{}/ABSA15_Restaurants_Test_Unique.txt'.format(txt_data_files)\n",
    "w2v_utils.getTraining_setFile(\"Total Validation Sentences with categories:\",test_Input_File, test_output_File)\n",
    "w2v_utils.getSentencesFile(test_Input_File, test_Unique_Sentences)\n",
    "\n",
    "###Gold Standard Annotations###\n",
    "gold_Input_File  = '{}/EN_REST_SB1_TEST.xml.gold'.format(xml_data_files)\n",
    "gold_output_File = '{}/EN_REST_SB1_TEST_gold.txt'.format(txt_data_files)\n",
    "gold_Unique_Sentences = '{}/EN_REST_SB1_TEST_gold_Unique.txt'.format(txt_data_files)\n",
    "w2v_utils.getTraining_setFile(\"Total Gold Test set Sentences with categories:\",gold_Input_File, gold_output_File)\n",
    "w2v_utils.getSentencesFile(gold_Input_File, gold_Unique_Sentences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading trained (yelp 5lac and training) Google word2vec Model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-09-17 00:18:38,464 : INFO : loading Word2Vec object from word2vec_model/400dm_by_5lac_yelp.model\n",
      "2020-09-17 00:18:38,774 : INFO : loading syn0 from word2vec_model/400dm_by_5lac_yelp.model.syn0.npy with mmap=None\n",
      "2020-09-17 00:18:38,825 : INFO : loading syn1 from word2vec_model/400dm_by_5lac_yelp.model.syn1.npy with mmap=None\n",
      "2020-09-17 00:18:38,873 : INFO : Model saved using code from earlier Gensim Version. Re-loading old model in a compatible way.\n",
      "2020-09-17 00:18:38,874 : INFO : loading Word2Vec object from word2vec_model/400dm_by_5lac_yelp.model\n",
      "2020-09-17 00:18:39,213 : INFO : loading syn0 from word2vec_model/400dm_by_5lac_yelp.model.syn0.npy with mmap=None\n",
      "2020-09-17 00:18:39,258 : INFO : loading syn1 from word2vec_model/400dm_by_5lac_yelp.model.syn1.npy with mmap=None\n",
      "2020-09-17 00:18:39,308 : INFO : setting ignored attribute syn0norm to None\n",
      "2020-09-17 00:18:39,309 : INFO : setting ignored attribute cum_table to None\n",
      "2020-09-17 00:18:39,309 : INFO : loaded word2vec_model/400dm_by_5lac_yelp.model\n"
     ]
    }
   ],
   "source": [
    "#model = Word2Vec.load('TRAIN_MODEL')\n",
    "model = Word2Vec.load('word2vec_model/400dm_by_5lac_yelp.model')\n",
    "#print \"Loading GoogleNews-vectors-negative300.bin model\" \n",
    "#model = Word2Vec.load_word2vec_format('/home/nouman/Python codes/ABSA_code/GoogleNews-vectors-negative300.bin', binary=True) \n",
    "#print \"Model loaded...\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:1: DeprecationWarning: Call to deprecated `most_similar` (Method will be removed in 4.0.0, use self.wv.most_similar() instead).\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n",
      "2020-09-17 00:18:39,418 : INFO : precomputing L2-norms of word weight vectors\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('decent', 0.6036416292190552),\n",
       " ('great', 0.5459213852882385),\n",
       " ('tasty', 0.5145878195762634),\n",
       " ('awesome', 0.43889498710632324),\n",
       " ('solid', 0.42857787013053894),\n",
       " ('excellent', 0.41170811653137207),\n",
       " ('tastey', 0.40314656496047974),\n",
       " ('average', 0.39288848638534546),\n",
       " ('yummy', 0.38846299052238464),\n",
       " ('amazing', 0.384460985660553)]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.most_similar(\"good\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:1: DeprecationWarning: Call to deprecated `most_similar` (Method will be removed in 4.0.0, use self.wv.most_similar() instead).\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('terrible', 0.5134795904159546),\n",
       " ('horrible', 0.474630206823349),\n",
       " ('awful', 0.4508820176124573),\n",
       " ('poor', 0.4300382733345032),\n",
       " ('soured', 0.39991259574890137),\n",
       " ('horrific', 0.38495567440986633),\n",
       " ('good', 0.3828938603401184),\n",
       " ('tainted', 0.38143378496170044),\n",
       " ('negative', 0.37759342789649963),\n",
       " ('lousy', 0.3643159866333008)]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.most_similar(\"bad\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading training and test setences from files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "training_output_File = '{}/ABSA16_Restaurants_Train_SB1_v2.txt'.format(txt_data_files)\n",
    "test_output_File = '{}/ABSA15_Restaurants_Test.txt'.format(txt_data_files)\n",
    "gold_output_File = '{}/EN_REST_SB1_TEST_gold.txt'.format(txt_data_files)\n",
    "finalTrain = 'file'\n",
    "train = pd.read_csv(training_output_File, header=None, delimiter=\"\\t\", quoting=3, names=['review', 'category'])\n",
    "test  = pd.read_csv(gold_output_File, header=None, delimiter=\"\\t\", quoting=3, names=['review', 'category'])\n",
    "train = w2v_utils.multiHotVectors(train, 'test_labels')\n",
    "test  = w2v_utils.multiHotVectors(test, 'train_labels')\n",
    "train.to_csv('{}/train.csv'.format(csv_data_files))\n",
    "test.to_csv('{}/test.csv'.format(csv_data_files))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting one Hot encodings of the labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hot encoded vectors shape:  (1708, 12)\n",
      "Hot encoded vectors shape:  (587, 12)\n",
      "They never brought us complimentary noodles, ignored repeated requests for sugar, and threw our dishes on the table. [0 0 0 0 0 0 0 0 0 0 0 1]\n",
      "Not the biggest portions but adequate. [0 0 0 0 0 0 1 0 0 0 0 0]\n",
      "Cleaning sentences from training set...\n",
      "Training Set: 1452 Validation Set: 256 Gold Set: 587\n"
     ]
    }
   ],
   "source": [
    "x_train = train[\"review\"]\n",
    "Y_train = np.array(w2v_utils.multiCategoryVectors(train, classes=12)).astype(int) #train[\"category\"]\n",
    "x_test  = test[\"review\"]\n",
    "Y_test  = np.array(w2v_utils.multiCategoryVectors(test, classes=12)).astype(int)  #test[\"category\"]\n",
    "\n",
    "print (train[\"review\"][2], Y_train[2])\n",
    "print (test[\"review\"][2],  Y_test[2])\n",
    "\n",
    "\n",
    "# preparing  data\n",
    "x_train,Y_train,x_val,Y_val =  w2v_utils.splitDataset(x_train, Y_train, split=0.85) \n",
    "\n",
    "####################################### CLEANING REVIEWS ###############################################################\n",
    "print (\"Cleaning sentences from training set...\")\n",
    "x_train = w2v_utils.clean(x_train, True)\n",
    "x_val = w2v_utils.clean(x_val,True)\n",
    "x_test = w2v_utils.clean(x_test,True)\n",
    "print (\"Training Set:\",len(x_train), \"Validation Set:\",len(x_val), \"Gold Set:\",len(x_test))#,\"Test Set:\",len(x_test) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sentence Compression Method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Process of word to vector conversion initiated!\n",
      "Empty Sentence\n",
      "Empty Sentence\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:82: DeprecationWarning: Call to deprecated `layer1_size` (Attribute will be removed in 4.0.0, use self.trainables.layer1_size instead).\n",
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:27: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training set Sentences word vector dimensions: \n",
      " (1452, 400)\n",
      "Validation set Sentences word vector dimensions: \n",
      " (256, 400)\n",
      "Gold Sentences word vector dimensions: \n",
      " (587, 400)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:88: DeprecationWarning: Call to deprecated `layer1_size` (Attribute will be removed in 4.0.0, use self.trainables.layer1_size instead).\n",
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:93: DeprecationWarning: Call to deprecated `layer1_size` (Attribute will be removed in 4.0.0, use self.trainables.layer1_size instead).\n"
     ]
    }
   ],
   "source": [
    "######## getting sentence vectors\n",
    "print (\"Process of word to vector conversion initiated!\")\n",
    "\n",
    "#Build word vector for training set by using the average value of all word vectors in the tweet, then scale\n",
    "def buildWordVector(text, size, debug = False):\n",
    "    sentWords = len(text)  \n",
    "    #print (text, \"Sentence Words:\",sentWords)\n",
    "    if (sentWords == 0):\n",
    "        print (\"Empty Sentence\" )\n",
    "        #return np.zeros(size*2).reshape((1, size*2))\n",
    "        return np.zeros(size).reshape((1, size))\n",
    "\n",
    "    count = 0.\n",
    "    vecSum      = np.zeros(size).reshape((1, size))\n",
    "    vecMin      = np.zeros(size).reshape((1, size))\n",
    "    avgvecSum   = np.zeros(size).reshape((1, size))\n",
    "    avgvecMin   = np.zeros(size).reshape((1, size))\n",
    "    NAV_L1      = np.zeros(size).reshape((1, size))\n",
    "    NAV_L2      = np.zeros(size).reshape((1, size))\n",
    "    L1_SOM      = np.zeros(size).reshape((1, size))\n",
    "    L2_SOM      = np.zeros(size).reshape((1, size))\n",
    "    mul_wordVec = np.zeros(size).reshape((1, size))\n",
    "    \n",
    "    #Loop started!!\n",
    "    for word in text:\n",
    "        try:\n",
    "            wordVector = model[word].reshape((1, size))\n",
    "            #vecSum = vecSum + wordVector\n",
    "            if count != 0:\n",
    "                vecSum      =  vecSum+wordVector\n",
    "                vecMin      =  vecMin+wordVector\n",
    "                mul_wordVec = mul_wordVec*wordVector\n",
    "            else:\n",
    "                vecSum      =  wordVector\n",
    "                vecMin      =  wordVector\n",
    "                mul_wordVec =  wordVector\n",
    "                \n",
    "            count  = count+1.\n",
    "            \n",
    "        except KeyError:\n",
    "            if debug:\n",
    "                print (\"not found! \",  word)\n",
    "                count += 1.\n",
    "            continue\n",
    "    #Loop ends!!\n",
    "    \n",
    "    if count != 0:\n",
    "        ###### Multiply word vectors\n",
    "        mul_wordVec = mul_wordVec/1\n",
    "        \n",
    "        ###### Sum and Subract ######\n",
    "        vecSum  = vecSum/1\n",
    "        vecMin  = vecMin/1\n",
    "        avgvecSum = vecSum #SOW\n",
    "        avgvecMin = vecMin #DOW\n",
    "        ##concatenating both sum and subtraction of word vectors\n",
    "        con_vecSum_vecMin = np.hstack((vecSum,vecMin)) #CONC-Vec\n",
    "        \n",
    "        \n",
    "        ###### Average Sum and Subract ######      \n",
    "        avgvecSum = avgvecSum/count #Avg-SUM\n",
    "        avgvecMin = avgvecMin/count #Avg-SUB\n",
    "        \n",
    "        ###### Normalized Average Sum and Subract ######        \n",
    "        NAV_L1 = avgvecSum/np.linalg.norm(avgvecSum,ord=1)    #L1-NAV (Sum)\n",
    "        NAV_L2 = avgvecSum/np.linalg.norm(avgvecSum, axis=1)  #L2-NAV (Sum)\n",
    "        \n",
    "        NAV_L1_Sub = avgvecMin/np.linalg.norm(avgvecMin,ord=1)    #L1-NAV (Sub)\n",
    "        NAV_L2_Sub = avgvecMin/np.linalg.norm(avgvecMin, axis=1)  #L2-NAV (Sub)\n",
    "        \n",
    "        ############ Normalized Word Vectors #############\n",
    "        ###### L1-SOM ######\n",
    "        L1_SOM = vecSum/np.linalg.norm(vecSum,ord=1)   #L1-NV (Sum)\n",
    "        L2_SOM = vecSum/np.linalg.norm(vecSum, axis=1) #L2-NV (Sum)\n",
    "        \n",
    "        L1_SOM_Sub = vecMin/np.linalg.norm(vecSum,ord=1)   #L1-NV (Sub)\n",
    "        L2_SOM_Sub = vecMin/np.linalg.norm(vecSum, axis=1) #L2-NV (Sub)\n",
    "\n",
    "    return vecSum\n",
    "\n",
    "######## Converting training, validation and test sentences into vectors\n",
    "x_train = np.concatenate([buildWordVector(sentence, model.layer1_size, debug = False) for sentence in x_train])\n",
    "if(scaleVectors):\n",
    "    x_train = scale(x_train)\n",
    "print (\"Training set Sentences word vector dimensions: \\n\",x_train.shape)\n",
    "\n",
    "if (setValidation):\n",
    "    x_val = np.concatenate([buildWordVector(sentence, model.layer1_size, debug = False) for sentence in x_val]) \n",
    "    if(scaleVectors):\n",
    "        x_val = scale(x_val)\n",
    "    print (\"Validation set Sentences word vector dimensions: \\n\",x_val.shape)\n",
    "    \n",
    "x_test = np.concatenate([buildWordVector(sentence, model.layer1_size, debug = False) for sentence in x_test])\n",
    "if(scaleVectors):\n",
    "    x_test = scale(x_test)\n",
    "print (\"Gold Sentences word vector dimensions: \\n\",x_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Plotting Setence vectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TSNE graphical representation of vectors loading...\n",
      "Training Sentences REDUCED word vector dimensions: \n",
      " (1452, 2)\n",
      "Validation Sentences REDUCED word vector dimensions: \n",
      " (256, 2)\n",
      "Gold Sentences REDUCED word vector dimensions: \n",
      " (587, 2)\n"
     ]
    }
   ],
   "source": [
    "if skipSections:\n",
    "    print (\"TSNE graphical representation of vectors loading...\")\n",
    "    #Plot Word Vectors in 2-dimensional space\n",
    "    ts = TSNE(2)\n",
    "    reduced_trained_vectors = ts.fit_transform(x_train)\n",
    "    print (\"Training Sentences REDUCED word vector dimensions: \\n\",reduced_trained_vectors.shape)\n",
    "\n",
    "    if (setValidation):\n",
    "        reduced_validation_vectors = ts.fit_transform(x_val)\n",
    "        print (\"Validation Sentences REDUCED word vector dimensions: \\n\",reduced_validation_vectors.shape)\n",
    "\n",
    "    reduced_gold_vectors = ts.fit_transform(x_test)\n",
    "    print (\"Gold Sentences REDUCED word vector dimensions: \\n\",reduced_gold_vectors.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if skipSections:\n",
    "    #color points by word group to see if Word2Vec can separate them\n",
    "    for i in range(len(reduced_trained_vectors)):\n",
    "        if i < len(x_train):\n",
    "            color = 'r'\n",
    "        plt.plot(reduced_trained_vectors[i,0], reduced_trained_vectors[i,1], marker='o', color=color, markersize=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if skipSections:\n",
    "    if (setValidation):\n",
    "        #color points by word group to see if Word2Vec can separate them\n",
    "        for i in range(len(reduced_validation_vectors)):\n",
    "            if i < len(x_val):\n",
    "                color = 'b'\n",
    "            plt.plot(reduced_validation_vectors[i,0], reduced_validation_vectors[i,1], marker='o', color=color, markersize=6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if skipSections:    \n",
    "    #color points by word group to see if Word2Vec can separate them\n",
    "    for i in range(len(reduced_gold_vectors)):\n",
    "        if i < len(x_test):\n",
    "            color = 'k'\n",
    "        plt.plot(reduced_trained_vectors[i,0], reduced_gold_vectors[i,1], marker='o', color=color, markersize=6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Converting x_ and y_ sets for training and testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Data:  (1452, 400) (1452, 12)\n",
      "Validation Data:  (256, 400) (256, 12)\n",
      "Gold Test Data:  (587, 400) (587, 12)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(array([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]),\n",
       " array([0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1]),\n",
       " array([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Entities   = np.array(['FOOD', 'SERVICE', 'DRINKS', 'AMBIENCE', 'LOCATION', 'RESTAURANT'])\n",
    "#Attributes = np.array(['GENERAL', 'QUALITY', 'STYLE_OPTIONS', 'MISCELLANEOUS', 'PRICES'])\n",
    "\n",
    "############################### Preparing Data with One Hot #######################################\n",
    "X_train = x_train \n",
    "y_train = Y_train\n",
    "print (\"Training Data: \",X_train.shape, y_train.shape)\n",
    "\n",
    "###############################Preparing Validation Data\n",
    "X_val = x_val\n",
    "y_val = Y_val\n",
    "print (\"Validation Data: \",X_val.shape, y_val.shape)\n",
    "\n",
    "###############################Preparing Test Gold Data\n",
    "X_test = x_test\n",
    "y_test = Y_test\n",
    "print (\"Gold Test Data: \", X_test.shape,y_test.shape)\n",
    "\n",
    "y_train[0], y_val[0], y_test[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Category Distribution Chart"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[226  20  46  30  82 681 128  28 421  97  80 419] [ 57   3  21  12  22 226  48  13 142  33  21 145]\n",
      "Total number of Training set Categories:  12\n",
      "Total number of Training set Categories:  11\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Number of Aspect categories in Reviews')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Frequencies of categories\n",
    "categories = np.array(['AMBIENCE#GENERAL','DRINKS#PRICES','DRINKS#QUALITY','DRINKS#STYLE_OPTIONS','FOOD#PRICES','FOOD#QUALITY','FOOD#STYLE_OPTIONS','LOCATION#GENERAL','RESTAURANT#GENERAL','RESTAURANT#MISCELLANEOUS','RESTAURANT#PRICES','SERVICE#GENERAL'])\n",
    "y_tr  = np.nonzero(y_train)[1]\n",
    "y_tr  = np.bincount(y_tr)\n",
    "\n",
    "y_va  = np.nonzero(y_val)[1]\n",
    "y_va  = np.bincount(y_va)\n",
    "\n",
    "y_te  = np.nonzero(y_test)[1]\n",
    "y_te  =  np.bincount(y_te)\n",
    "\n",
    "trainCat = y_tr+y_va\n",
    "testCat  = y_te\n",
    "print (trainCat, testCat)\n",
    "\n",
    "#Categories in training set\n",
    "trainFreq = pd.Series(trainCat, index=[trainCat])\n",
    "print (\"Total number of Training set Categories: \", trainFreq.value_counts().size)\n",
    "trainFreq = pd.Series(trainFreq.get_values(),  index=categories)\n",
    "#trainFreq.plot(kind='pie',title='Training Set Categories', figsize=(10, 10))\n",
    "gra_1 = trainFreq.plot(lw=2, kind='bar', stacked=True, figsize=(10, 8), color='r',fontsize=10)\n",
    "\n",
    "#Categories in test set\n",
    "testFreq = pd.Series(testCat, index=[testCat])\n",
    "print (\"Total number of Training set Categories: \", testFreq.value_counts().size)\n",
    "testFreq = pd.Series(testFreq.values,  index=categories)\n",
    "#testFreq.plot(kind='pie', title='Test Set Categories', figsize=(10, 10))\n",
    "gra_1 = testFreq.plot(lw=2, kind='bar', stacked=True,figsize=(10, 6), color='g', fontsize=10)\n",
    "\n",
    "gra_1.set_title('Histogram of Aspect Categories Distribution accross Restaurant Reviews\\n', fontsize=16)\n",
    "gra_1.set_ylabel(\"Number of Aspects in a Reviews\", fontsize=14)\n",
    "gra_1.set_xlabel(\"Number of Aspect categories in Reviews\", fontsize=14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nueral Network Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/tensorflow_core/python/compat/v2_compat.py:88: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "non-resource variables are not supported in the long term\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-09-17 00:18:54,199 : WARNING : From /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/tensorflow_core/python/compat/v2_compat.py:88: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "non-resource variables are not supported in the long term\n"
     ]
    }
   ],
   "source": [
    "import tensorflow.compat.v1 as tf\n",
    "tf.disable_v2_behavior()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1635: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "If using Keras pass *_constraint arguments to layers.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-09-17 00:18:54,284 : WARNING : From /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/tensorflow_core/python/ops/resource_variable_ops.py:1635: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "If using Keras pass *_constraint arguments to layers.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-15-fc70e274bf9a>:68: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-09-17 00:18:54,312 : WARNING : From <ipython-input-15-fc70e274bf9a>:68: softmax_cross_entropy_with_logits (from tensorflow.python.ops.nn_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "\n",
      "Future major versions of TensorFlow will allow gradients to flow\n",
      "into the labels input on backprop by default.\n",
      "\n",
      "See `tf.nn.softmax_cross_entropy_with_logits_v2`.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/tensorflow_core/python/util/tf_should_use.py:235: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n",
      "Instructions for updating:\n",
      "Use `tf.global_variables_initializer` instead.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2020-09-17 00:18:54,431 : WARNING : From /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/tensorflow_core/python/util/tf_should_use.py:235: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n",
      "Instructions for updating:\n",
      "Use `tf.global_variables_initializer` instead.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Network Initialized!\n"
     ]
    }
   ],
   "source": [
    "# Parameters\n",
    "training_epochs = 100\n",
    "batch_size = 80\n",
    "display_step = 5\n",
    "batch = tf.Variable(0, trainable=False)\n",
    "regualarization =  0.001\n",
    "\n",
    "# Network Parameters\n",
    "n_hidden_1 = 300 # 1st layer num features\n",
    "n_hidden_2 = 250 # 2nd layer num features\n",
    "\n",
    "n_input = X_test.shape[1] #model.layer1_size # Vector input (sentence shape: 30*10)\n",
    "n_classes = 12 # Sentence Category detection total classes (0-11 categories)\n",
    "\n",
    "#History storing variables for plots\n",
    "loss_history = []\n",
    "train_acc_history = []\n",
    "val_acc_history = []\n",
    "\n",
    "# tf Graph input\n",
    "x = tf.placeholder(\"float\", [None, n_input])\n",
    "y = tf.placeholder(\"float\", [None, n_classes])\n",
    "\n",
    "\n",
    "# Create model\n",
    "def multilayer_perceptron(_X, _weights, _biases):\n",
    "    layer_1 = tf.nn.relu(tf.add(tf.matmul(_X, _weights['h1']), _biases['b1'])) \n",
    "    layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, _weights['h2']), _biases['b2'])) \n",
    "    return tf.matmul(layer_2, weights['out']) + biases['out']  \n",
    "\n",
    "\n",
    "# Store layers weight & bias\n",
    "reset = True #if false then weights will not be initialized randomly \n",
    "if  (reset == True):\n",
    "    w2v_utils.resetModel()#delete old weights\n",
    "    \n",
    "weights = {\n",
    "    'h1':  w2v_utils.weight_variable(n_input, n_hidden_1,    filename=\"params/weights_h1.txt\",  boolean=reset),\n",
    "    'h2':  w2v_utils.weight_variable(n_hidden_1, n_hidden_2, filename=\"params/weights_h2.txt\",  boolean=reset),\n",
    "    'out': w2v_utils.weight_variable(n_hidden_2, n_classes,  filename=\"params/weights_out.txt\", boolean=reset) \n",
    "}\n",
    "\n",
    "biases = {\n",
    "    'b1': w2v_utils.bias_variable([n_hidden_1], filename=\"params/biases_b1.txt\", boolean=reset),\n",
    "    'b2': w2v_utils.bias_variable([n_hidden_2], filename=\"params/biases_b2.txt\", boolean=reset),\n",
    "    'out': w2v_utils.bias_variable([n_classes], filename=\"params/biases_out.txt\", boolean=reset)\n",
    "}\n",
    "    \n",
    "# Define loss and optimizer\n",
    "#learning rate\n",
    "#Optimizer: set up a variable that's incremented once per batch and\n",
    "# controls the learning rate decay.\n",
    "learning_rate = tf.train.exponential_decay(\n",
    "  0.003,           # Base learning rate. #0.002\n",
    "  batch * batch_size,  # Current index into the dataset.\n",
    "  X_train.shape[0],    # Decay step.\n",
    "  0.96,                # Decay rate.\n",
    "  staircase=True)\n",
    "\n",
    "\n",
    "# Construct model\n",
    "pred = tf.nn.sigmoid(multilayer_perceptron(x, weights, biases))\n",
    "\n",
    "#L2 regularization\n",
    "l2_loss = tf.add_n([tf.nn.l2_loss(v) for v in tf.trainable_variables()])\n",
    "    \n",
    "#Softmax loss\n",
    "cost = cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))  #labels=..., logits=.\n",
    "\n",
    "#Total_cost\n",
    "cost = cost+ (regualarization*0.5*l2_loss)\n",
    "\n",
    "# Adam Optimizer\n",
    "optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost,global_step=batch)\n",
    "\n",
    "# Initializing the variables\n",
    "init = tf.initialize_all_variables()\n",
    "\n",
    "print (\"Network Initialized!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/ipykernel_launcher.py:22: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0001 cost= 2.999312740 train= 0.446281 val= 0.47265625\n",
      "Epoch: 0006 cost= 2.643694075 train= 0.530303 val= 0.515625\n",
      "Epoch: 0011 cost= 2.546514059 train= 0.6990358 val= 0.63671875\n",
      "Epoch: 0016 cost= 2.438708795 train= 0.73415977 val= 0.6640625\n",
      "Epoch: 0021 cost= 2.418159272 train= 0.7651515 val= 0.66796875\n",
      "Epoch: 0026 cost= 2.410787106 train= 0.7789256 val= 0.66796875\n",
      "Epoch: 0031 cost= 2.360075085 train= 0.7885675 val= 0.66015625\n",
      "Epoch: 0036 cost= 2.359157989 train= 0.8002755 val= 0.66796875\n",
      "Epoch: 0041 cost= 2.357657407 train= 0.8009642 val= 0.671875\n",
      "Epoch: 0046 cost= 2.404181782 train= 0.8016529 val= 0.66015625\n",
      "Epoch: 0051 cost= 2.380323159 train= 0.8002755 val= 0.6484375\n",
      "Epoch: 0056 cost= 2.377243130 train= 0.8044077 val= 0.65234375\n",
      "Epoch: 0061 cost= 2.333173375 train= 0.80785125 val= 0.64453125\n",
      "Epoch: 0066 cost= 2.331101342 train= 0.80922866 val= 0.64453125\n",
      "Epoch: 0071 cost= 2.339485244 train= 0.80785125 val= 0.64453125\n",
      "Epoch: 0076 cost= 2.361305538 train= 0.80922866 val= 0.640625\n",
      "Epoch: 0081 cost= 2.346478512 train= 0.8140496 val= 0.640625\n",
      "Epoch: 0086 cost= 2.347457999 train= 0.81198347 val= 0.640625\n",
      "Epoch: 0091 cost= 2.347247613 train= 0.81198347 val= 0.64453125\n",
      "Epoch: 0096 cost= 2.339838982 train= 0.8126722 val= 0.640625\n",
      "Optimization Finished!\n",
      "\n",
      "Model Parameters Shape:\n",
      "(400, 300) (300, 250) (250, 12)\n",
      "(300,) (250,) (12,)\n"
     ]
    }
   ],
   "source": [
    "from __future__ import division\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import roc_auc_score\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "LoadTrainedModel = False\n",
    "\n",
    "truePred=0\n",
    "falsePred=0\n",
    "TP = 0\n",
    "FN = 0\n",
    "FP = 0\n",
    "TN = 0\n",
    "\n",
    "###http://stackoverflow.com/questions/33759623/tensorflow-how-to-restore-a-previously-saved-model-python\n",
    "# Launch the graph\n",
    "with tf.Session() as sess:\n",
    "    sess.run(init)\n",
    "    if(LoadTrainedModel == False):\n",
    "        data = list(zip(X_train,y_train))\n",
    "        data = np.array(data)\n",
    "        data_size = len(data)\n",
    "        num_batches_per_epoch = int(len(data)/batch_size) + 1\n",
    "        for epoch in range(training_epochs):\n",
    "            avg_cost = 0.\n",
    "            # Shuffle the data at each epoch\n",
    "            shuffle_indices = np.random.permutation(np.arange(data_size))\n",
    "            shuffled_data = data[shuffle_indices]\n",
    "            for batch_num in range(num_batches_per_epoch):\n",
    "                start_index = batch_num * batch_size\n",
    "                end_index = min((batch_num + 1) * batch_size, data_size)\n",
    "                sample = list(zip(*shuffled_data[start_index:end_index]))\n",
    "                #picking up random batches from training set of specific size\n",
    "                batch_xs, batch_ys = sample[0],sample[1]\n",
    "                # Fit training using batch data\n",
    "                sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})\n",
    "                # Compute average loss\n",
    "                avg_cost += sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})/num_batches_per_epoch\n",
    "            #append loss\n",
    "            #loss_history.append(avg_cost)\n",
    "\n",
    "            # Display logs per epoch step\n",
    "            if (epoch % display_step == 0):           \n",
    "                correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))            \n",
    "                # Calculate training  accuracy\n",
    "                accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "                trainAccuracy = accuracy.eval({x: X_train, y: y_train})\n",
    "                train_acc_history.append(trainAccuracy)  \n",
    "                loss_history.append(avg_cost)\n",
    "                # Calculate validation  accuracy\n",
    "                valAccuracy = accuracy.eval({x: X_val, y: y_val})\n",
    "                val_acc_history.append(valAccuracy) \n",
    "                print (\"Epoch:\", '%04d' % (epoch+1), \"cost=\", \"{:.9f}\".format(avg_cost), \"train=\",trainAccuracy,\"val=\", valAccuracy)\n",
    "        print (\"Optimization Finished!\\n\")\n",
    "\n",
    "        w2v_utils.resetModel()#delete old weights\n",
    "        # code save numpy arrays\n",
    "        np.savetxt(\"params/weights_h1.txt\", weights['h1'].eval())\n",
    "        np.savetxt(\"params/weights_h2.txt\", weights['h2'].eval()) \n",
    "        np.savetxt(\"params/weights_out.txt\", weights['out'].eval()) \n",
    "        np.savetxt(\"params/biases_b1.txt\",biases['b1'].eval())\n",
    "        np.savetxt(\"params/biases_b2.txt\",biases['b2'].eval())\n",
    "        np.savetxt(\"params/biases_out.txt\",biases['out'].eval())\n",
    "\n",
    "        print (\"Model Parameters Shape:\")\n",
    "        print( weights['h1'].eval().shape,  weights['h2'].eval().shape, weights['out'].eval().shape)\n",
    "        print (biases['b1'].eval().shape, biases['b2'].eval().shape, biases['out'].eval().shape)\n",
    "\n",
    "        predictedlabel = np.zeros(y_test.shape)\n",
    "        corrPred=0\n",
    "        # Evaluation of  model\n",
    "        correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) \n",
    "        # Calculate accuracy\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "        w2v_utils.do_eval(\"\",\"\",\"\", sess, correct_prediction, accuracy, pred, X_test, y_test, x, y)\n",
    "\n",
    "        #Test\n",
    "        #'''\n",
    "        for i in range(len(X_test)): #X_test\n",
    "            if (i<=len(y_test)):    \n",
    "                check,predictedlabel[i], TP_, FP_, TN_, FN_ = w2v_utils.do_eval(test[\"review\"][i],i,\"Accuracy of Test set Results: \", sess, correct_prediction, \n",
    "                                                                 accuracy, pred, X_test[i:i+1], y_test[i:i+1], \n",
    "                                                                 x, y, True, 0.785, debug=False)\n",
    "                TP = TP+TP_\n",
    "                FP = FP+FP_\n",
    "                TN = TN+TN_\n",
    "                FN = FN+FN_\n",
    "\n",
    "                if check == True:\n",
    "                    truePred = truePred+1\n",
    "                else:\n",
    "                    falsePred = falsePred+1\n",
    "        #'''\n",
    "    else:\n",
    "        predictedlabel = np.zeros(y_test.shape)\n",
    "        corrPred=0\n",
    "        # Evaluation of  model\n",
    "        correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) \n",
    "        \n",
    "        # Calculate accuracy\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n",
    "        w2v_utils.do_eval(\"\",\"\",\"\",  sess, correct_prediction, accuracy, pred, X_test, y_test, x, y) #test set\n",
    "\n",
    "        #Test\n",
    "        #'''\n",
    "        for i in range(len(X_test)): #X_test\n",
    "            if (i<=len(y_test)):    \n",
    "                check,predictedlabel[i], TP_, FP_, TN_, FN_ = w2v_utils.do_eval(test[\"review\"][i],i,\"Accuracy of Test set Results: \", sess, correct_prediction, \n",
    "                                                                 accuracy, pred, X_test[i:i+1], y_test[i:i+1], \n",
    "                                                                 x, y, True, 0.785, debug=False)\n",
    "                TP = TP+TP_\n",
    "                FP = FP+FP_\n",
    "                TN = TN+TN_\n",
    "                FN = FN+FN_\n",
    "\n",
    "                if check == True:\n",
    "                    truePred = truePred+1\n",
    "                else:\n",
    "                    falsePred = falsePred+1\n",
    "        #'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TP: 553 FP: 167\n",
      "FN: 190 TN: 0\n",
      "Precision: 0.7680555555555556\n",
      "Recall   : 0.7442799461641992\n",
      "F1 calculated by me!: 0.7559808612440192\n",
      "F1 calculated by AUEB: 0.7559808612440192\n",
      "F1 micro averaging Library function: 0.7559808612440192\n",
      "\n",
      "-------------------------Classification report:------------------------ \n",
      "\n",
      "                           precision    recall  f1-score   support\n",
      "\n",
      "        AMBIENCE#GENERAL       0.74      0.93      0.82        57\n",
      "           DRINKS#PRICES       0.00      0.00      0.00         3\n",
      "          DRINKS#QUALITY       0.00      0.00      0.00        21\n",
      "    DRINKS#STYLE_OPTIONS       0.70      0.58      0.64        12\n",
      "             FOOD#PRICES       0.50      0.59      0.54        22\n",
      "            FOOD#QUALITY       0.83      0.90      0.86       226\n",
      "      FOOD#STYLE_OPTIONS       0.62      0.54      0.58        48\n",
      "        LOCATION#GENERAL       0.00      0.00      0.00        13\n",
      "      RESTAURANT#GENERAL       0.78      0.73      0.75       142\n",
      "RESTAURANT#MISCELLANEOUS       0.48      0.30      0.37        33\n",
      "       RESTAURANT#PRICES       0.43      0.48      0.45        21\n",
      "         SERVICE#GENERAL       0.87      0.87      0.87       145\n",
      "\n",
      "          \n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/sklearn/metrics/_classification.py:1221: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/sklearn/metrics/_classification.py:1221: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in samples with no predicted labels. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "total = np.nonzero(y_test)\n",
    "\n",
    "#print \"\\n<------------Correct and inccorrect predictions------------>\"\n",
    "print (\"TP:\",TP,\"FP:\",FP)\n",
    "print (\"FN:\",FN,\"TN:\",TN)\n",
    "\n",
    "precision =  TP/(TP+FP)\n",
    "recall    =  TP/(TP+FN)\n",
    "F1 = 2*(precision*recall)/(precision+recall)\n",
    "F1_ = (1 + 1 ** 2) * precision * recall / ((precision * 1 ** 2) + recall) if precision > 0 and recall > 0 else 0.\n",
    "print (\"Precision:\",precision)\n",
    "print (\"Recall   :\",recall)\n",
    "print (\"F1 calculated by me!:\",F1)\n",
    "print (\"F1 calculated by AUEB:\",F1_)\n",
    "print (\"F1 micro averaging Library function:\",(f1_score(y_test, predictedlabel, average='micro'))) #test\n",
    "\n",
    "y_test =  y_test.astype(int)\n",
    "predictedlabel = predictedlabel.astype(int)\n",
    "\n",
    "labels = np.array(['AMBIENCE#GENERAL','DRINKS#PRICES','DRINKS#QUALITY','DRINKS#STYLE_OPTIONS','FOOD#PRICES','FOOD#QUALITY','FOOD#STYLE_OPTIONS','LOCATION#GENERAL','RESTAURANT#GENERAL','RESTAURANT#MISCELLANEOUS','RESTAURANT#PRICES','SERVICE#GENERAL'])\n",
    "scores = (classification_report(y_test, predictedlabel, target_names=labels)) #test\n",
    "\n",
    "print (\"\\n-------------------------Classification report:------------------------ \\n\\n\", scores[:870])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training and Validation curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x576 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(loss_history)\n",
    "plt.xlabel('iteration')\n",
    "plt.ylabel('loss')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "#print train_acc_history\n",
    "plt.plot(train_acc_history)\n",
    "plt.plot(val_acc_history)\n",
    "plt.legend(['train', 'val'], loc='upper left')\n",
    "plt.xlabel('epoch')\n",
    "plt.ylabel('accuracy')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}