Text Classification Model.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-21T03:27:43.628313Z",
     "start_time": "2019-07-21T03:27:34.819524Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from keras import optimizers\n",
    "\n",
    "import sys\n",
    "from collections import Counter \n",
    "import pprint \n",
    "import math\n",
    "import argparse \n",
    "import os\n",
    "import collections\n",
    "import json\n",
    "import re\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt \n",
    "import seaborn as sns\n",
    "import random\n",
    "import time \n",
    "import pandas as pd\n",
    "import itertools\n",
    "from ast import literal_eval\n",
    "\n",
    "# funtions to handle labels\n",
    "from utils.handle_labels import get_tag_counts_and_labels\n",
    "from utils.handle_labels import drop_labels\n",
    "from utils.handle_labels import group_labels_new\n",
    "from utils.handle_labels import categories_count\n",
    "from utils.handle_labels import get_imbalance\n",
    "from utils.handle_labels import label_distribution\n",
    "from utils.handle_labels import number_of_labels\n",
    "#from utils.message_preprocess import message_processing\n",
    "from utils.prepocess_code_change import parse_json, preprocess_roots, actions2sentence,expand_list,permutate_files\n",
    "from utils.prepocess_code_change import get_seqlength,plot_hist,get_file_threshold,concat_files_to_sentence\n",
    "from utils.plot_utils import pie_plot\n",
    "from utils.embedding_utils import load_embedding\n",
    "\n",
    "np.random.seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Preparation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### processing labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1922, 28)\n",
      "<class 'list'>\n",
      "['Testing', 'Bug fix']\n",
      "Maintenance : 891\n",
      "Feature Add : 330\n",
      "Bug fix : 266\n",
      "Documentation : 237\n",
      "Clean up : 192\n",
      "Refactoring : 111\n",
      "Indentation : 48\n",
      "Token Replace : 40\n",
      "Source Control : 30\n",
      "Cross : 24\n",
      "Legal : 18\n",
      "Debug : 10\n",
      "Module Remove : 6\n",
      "Module Move : 5\n",
      "Rename : 5\n",
      "Versioning : 4\n",
      "Merge : 3\n",
      "Initialization : 2\n",
      "Internationalization : 1\n",
      "Data : 1\n",
      "Module Add : 1\n",
      "1    1625\n",
      "2     226\n",
      "3      35\n",
      "4       7\n",
      "5       3\n",
      "dtype: int64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Corrective : 266\n",
      "Adaptive : 237\n",
      "Perfective : 1093\n",
      "Implementation : 330\n",
      "Non_functional : 70\n",
      "Other : 34\n",
      "Corrective : 266\n",
      "Adaptive : 237\n",
      "Perfective : 1093\n",
      "Implementation : 330\n",
      "1    1616\n",
      "2     136\n",
      "0     132\n",
      "3      10\n",
      "4       2\n",
      "dtype: int64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current number of samples: 1896\n",
      "number of samples after drop:1616\n"
     ]
    }
   ],
   "source": [
    "# read data\n",
    "df = pd.read_csv('data/commit_data_new.csv')\n",
    "print(df.shape)\n",
    "\n",
    "df['categories'] = df['categories'].apply(lambda x: literal_eval(x))\n",
    "print(type(df['categories'].values[0]))\n",
    "print(df['categories'].values[0])\n",
    "df = df.drop(['Unnamed: 0'], axis = 1)\n",
    "df.head()\n",
    "\n",
    "# drop testing and build\n",
    "new_df = drop_labels(df, ['Testing', 'Build'])\n",
    "_ , target_col = get_tag_counts_and_labels(new_df)\n",
    "multi_count = number_of_labels(new_df, target_col)\n",
    "\n",
    "# merge some of categories\n",
    "new_df = group_labels_new(new_df, ['Bug fix'], 'Corrective')\n",
    "new_df = group_labels_new(new_df, ['Documentation'], 'Adaptive')\n",
    "new_df = group_labels_new(new_df, ['Clean up', 'Maintenance','Refactoring'], 'Perfective')\n",
    "new_df = group_labels_new(new_df, ['Feature Add'], 'Implementation')\n",
    "new_df = group_labels_new(new_df, ['Legal', 'Module Remove','Rename','Token Replace','Merge'], 'Non_functional')\n",
    "new_df = group_labels_new(new_df, ['Cross','Debug'], 'Other')\n",
    "\n",
    "target_col = ['Corrective','Adaptive','Perfective','Implementation','Non_functional','Other']\n",
    "multi_count = categories_count(new_df, target_col)\n",
    "\n",
    "# Drop 'Non-functional' and 'Other'\n",
    "new_df = new_df.drop(['Non_functional','Other'],axis = 1)\n",
    "\n",
    "target_col = ['Corrective','Adaptive','Perfective','Implementation']\n",
    "multi_count = categories_count(new_df, target_col)\n",
    "\n",
    "# Drop rows with multiple labels\n",
    "target_col = ['Corrective','Adaptive','Perfective','Implementation']\n",
    "multi_count = number_of_labels(new_df, target_col)\n",
    "\n",
    "print('current number of samples: %d'%new_df.shape[0])\n",
    "new_df['label_sum'] = new_df[target_col].sum(axis=1)\n",
    "new_df = new_df[new_df['label_sum']==1].reset_index(drop=True)\n",
    "print('number of samples after drop:%d'%new_df.shape[0])\n",
    "new_df = new_df.drop(['label_sum'], axis = 1)\n",
    "\n",
    "# Drop target col\n",
    "new_df = new_df[new_df['Corrective']!=1].reset_index(drop=True)\n",
    "target_col = ['Adaptive','Perfective','Implementation']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Read code change data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apache-avro_2df0775d2f368b326e3ac6442ce4850e3fe62edc.json\n",
      "472\n"
     ]
    }
   ],
   "source": [
    "# generate file name for search\n",
    "csha = new_df['Commit ID'].values\n",
    "files = [c + '.json' for c in csha]\n",
    "application_name = new_df['project name'].values\n",
    "files_path = []\n",
    "for project_name, c in zip(application_name,files):\n",
    "    files_path.append(project_name + '_' + c)\n",
    "print(files_path[0])\n",
    "\n",
    "# get code change data\n",
    "files = files_path\n",
    "folder_path = 'D:\\\\Research\\\\AllFiles_Research\\\\'\n",
    "all_files, csha = parse_json(folder_path, files)\n",
    "\n",
    "# preprocess_roots\n",
    "dic, datas, freq_dict = preprocess_roots(all_files)\n",
    "rev_dic = dict(zip(dic.values(), dic.keys()))\n",
    "print(len(dic))\n",
    "\n",
    "# concat action to sentence\n",
    "training_data = actions2sentence(datas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Permutate and get train data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1389, 29)\n",
      "exp_train_df shape: (6973, 30)\n",
      "train_df shape: (955, 30)\n",
      "test_df shape: (245, 30)\n"
     ]
    }
   ],
   "source": [
    "# merge csha and training data to a dataframe\n",
    "commits_df = pd.DataFrame(data = [csha, training_data]).T\n",
    "commits_df.columns = [\"Commit ID\", \"Files\"]\n",
    "print(new_df.shape)\n",
    "\n",
    "# merge two dataframe and drop some of labels\n",
    "commits_labels_df = pd.merge(commits_df, new_df, on='Commit ID')\n",
    "\n",
    "# split dataframe to train and test\n",
    "msk = np.random.rand(len(commits_labels_df)) < 0.8\n",
    "train_df = commits_labels_df[msk]\n",
    "test_df = commits_labels_df[~msk]\n",
    "\n",
    "# permutate train_df\n",
    "permutate_train_dic = permutate_files(train_df['Commit ID'],train_df['Files'])\n",
    "permutate_train_df = pd.DataFrame(list(permutate_train_dic.items()))\n",
    "permutate_train_df.columns = ['Commit ID','Files']\n",
    "train_df = train_df.drop([\"Files\"], axis=1)\n",
    "train_df['Files'] = permutate_train_df['Files'].values\n",
    "\n",
    "# expanded train_df list\n",
    "expanded_train_df = expand_list(train_df)\n",
    "\n",
    "print('exp_train_df shape:',expanded_train_df.shape)\n",
    "print('train_df shape:',train_df.shape)\n",
    "print('test_df shape:',test_df.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determine File Threshold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-21T03:27:53.112668Z",
     "start_time": "2019-07-21T03:27:46.510367Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INS_ImportDeclaration_CompilationUnit INS_ImportDeclaration_CompilationUnit INS_VariableDeclarationStatement_Block INS_EnhancedForStatement_Block\n",
      "<sample training data>:  ['INS_ImportDeclaration_CompilationUnit INS_ImportDeclaration_CompilationUnit INS_VariableDeclarationStatement_Block INS_EnhancedForStatement_Block']\n",
      "max length: 1656\n",
      "length threshold 42\n",
      "Index(['Commit ID', 'project name', 'commit_message', 'Maintenance',\n",
      "       'Feature Add', 'Bug fix', 'Documentation', 'Clean up', 'Refactoring',\n",
      "       'Indentation', 'Token Replace', 'Source Control', 'Cross', 'Legal',\n",
      "       'Debug', 'Module Remove', 'Module Move', 'Rename', 'Versioning',\n",
      "       'Merge', 'Initialization', 'Internationalization', 'Data', 'Module Add',\n",
      "       'categories', 'Corrective', 'Adaptive', 'Perfective', 'Implementation',\n",
      "       'Files', 'len_seq'],\n",
      "      dtype='object')\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABI8AAAJFCAYAAABUVtfqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdf2xd9X038I+T69hmsR/a6HpBKIpUWgnEVKhYgUyVLfQIO8S5C4vQFpqRTTwrAZUgIgSFkJGtayEwHkUgoNofFRI//iBkQEIUTFFZI7Who0QbUaasQ20SBmHhEgqJIf59nz+o7+P8+Nr32r6+/vF6/YPPud9zzufc87mx/eZ7jmsKhUIhAAAAAOAs5lS7AAAAAACmLuERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEgSHgEAAACQVHJ49OCDD8bdd98dEREHDhyIlStXRnt7e9x7773R398fERFHjhyJ1atXx9KlS+OWW26Jzz77rDJVAwAAADApSgqP3njjjXjxxReLy3feeWfcd9998eqrr0ahUIitW7dGRMTf//3fx7e//e3o7OyMP/qjP4onnniiMlUDAAAAMClGDY8++eST2LJlS9x8880REfH+++9Hd3d3XHrppRERsXLlyujs7Iy+vr741a9+Fe3t7aesBwAAAGD6GjU8uu+++2L9+vXR1NQUEREffvhhZLPZ4uvZbDaOHj0av/vd72L+/PmRyWROWQ8AAADA9DViePT888/HeeedF0uWLCmuGxwcjJqamuJyoVCImpqa4n+HO30ZAAAAgOklM9KLu3btinw+HytWrIhPP/00Pv/886ipqYl8Pl8c89FHH0Vzc3N8+ctfjhMnTsTAwEDMnTs38vl8NDc3l13Q7373WQwOFso/E2adBQvmx7FjXdUug2lAr1AO/UKp9Arl0C+USq9QDv1CKebMqYkvfekPxrWPEcOjJ598svj1Cy+8EG+++WY88MADsXz58ti7d29cdtllsX379mhpaYna2tr44z/+49i1a1fkcrl46aWXoqWlpeyCBgcLwiNKplcolV6hHPqFUukVyqFfKJVeoRz6hclQ0l9bO93DDz8cDzzwQCxdujQ+//zzWLNmTUREbNq0KbZu3RrLli2Lt956K26//fYJLRYAAACAyVVTKBSmVEx57FiX5JSSZLONkc+fqHYZTAN6hXLoF0qlVyiHfqFUeoVy6BdKMWdOTSxYMH98+5igWgAAAACYgYRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgKRMtQsoVWNTQ9TXZaK7pz9OHD9Z7XIAAAAAZoVpM/Oovi4TuTu2R33dtMm7AAAAAKa9aRMeAQAAADD5hEcAAAAAJAmPAAAAAEgSHgEAAACQJDwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEgSHgEAAACQJDwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEgSHgEAAACQJDwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEgSHgEAAACQJDwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEgSHgEAAACQJDwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJJUUHj3yyCOxbNmy6OjoiCeffDIiIu65555oa2uLFStWxIoVK+K1116LiIg9e/ZELpeLtra22LJlS+UqBwAAAKDiMqMNePPNN+OXv/xl7NixI/r7+2PZsmXR2toa+/fvj2eeeSaam5uLY7u7u2PDhg3x9NNPx3nnnRdr166N3bt3R2tra0VPAgAAAIDKGHXm0eWXXx5PPfVUZDKZOHbsWAwMDER9fX0cOXIkNmzYELlcLh599NEYHByMffv2xeLFi2PRokWRyWQil8tFZ2fnZJwHAAAAABVQ0m1rtbW18eijj0ZHR0csWbIk+vv748orr4z7778/tm7dGm+99VZs27YtPvzww8hms8Xtmpub4+jRoxUrHgAAAIDKGvW2tSG33XZbfOc734mbb7453njjjXj88ceLr91www3x0ksvRXt7e9TU1BTXFwqFU5ZLsWDB/FHHZLONZe2TmUsvUCq9Qjn0C6XSK5RDv1AqvUI59AuTYdTw6De/+U309vbGRRddFA0NDdHW1ha7du2Kc889N9rb2yPii5Aok8nEwoULI5/PF7fN5/OnPBOpFMeOdcXgYOGM9cM/EPn8ibL2ycyUzTbqBUqiVyiHfqFUeoVy6BdKpVcoh36hFHPm1JQ0UWfEfYw24L333ouNGzdGb29v9Pb2xk9/+tP45je/Gffff398+umn0dfXF88991xcffXVcckll8TBgwfj8OHDMTAwEDt37oyWlpZxFQgAAABA9Yw686i1tTX27dsX1157bcydOzfa2tri1ltvjS996Utx/fXXR39/f7S1tcXy5csjImLz5s2xbt266OnpidbW1li6dGnFTwIAAACAyqgpFApn3iNWRSPdtpa7Y3u8/H9XmJZHRJiiSen0CuXQL5RKr1AO/UKp9Arl0C+UYlJuWwMAAABg9hIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgqaTw6JFHHolly5ZFR0dHPPnkkxERsWfPnsjlctHW1hZbtmwpjj1w4ECsXLky2tvb4957743+/v7KVA4AAABAxY0aHr355pvxy1/+Mnbs2BH//M//HE8//XT853/+Z2zYsCGeeOKJ2LVrV+zfvz92794dERF33nln3HffffHqq69GoVCIrVu3VvwkAAAAAKiMUcOjyy+/PJ566qnIZDJx7NixGBgYiOPHj8fixYtj0aJFkclkIpfLRWdnZ7z//vvR3d0dl156aURErFy5Mjo7Oyt+EgAAAABURkm3rdXW1sajjz4aHR0dsWTJkvjwww8jm80WX29ubo6jR4+esT6bzcbRo0cnvmoAAAAAJkWm1IG33XZbfOc734mbb745Dh06FDU1NcXXCoVC1NTUxODg4FnXl2PBgvmjjslmG8vaJzOXXqBUeoVy6BdKpVcoh36hVHqFcugXJsOo4dFvfvOb6O3tjYsuuigaGhqira0tOjs7Y+7cucUx+Xw+mpubY+HChZHP54vrP/roo2hubi6roGPHumJwsHDG+uEfiHz+RFn7ZGbKZhv1AiXRK5RDv1AqvUI59Aul0iuUQ79QijlzakqaqDPiPkYb8N5778XGjRujt7c3ent746c//WmsWrUqDh48GIcPH46BgYHYuXNntLS0xPnnnx91dXWxd+/eiIjYvn17tLS0jKtAAAAAAKpn1JlHra2tsW/fvrj22mtj7ty50dbWFh0dHfHlL3851q1bFz09PdHa2hpLly6NiIiHH344Nm7cGF1dXXHxxRfHmjVrKn4SAAAAAFRGSc88WrduXaxbt+6UdUuWLIkdO3acMfbCCy+Mbdu2TUx1AAAAAFRVSX9tDQAAAIDZSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAAScIjAAAAAJKERwAAAAAkCY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAICkTCmDHnvssXjllVciIqK1tTXuuuuuuOeee2Lv3r3R0NAQERG33nprXH311bFnz5544IEHoqenJ6655ppYv3595aoHAAAAoKJGDY/27NkTP//5z+PFF1+Mmpqa+Ju/+Zt47bXXYv/+/fHMM89Ec3NzcWx3d3ds2LAhnn766TjvvPNi7dq1sXv37mhtba3oSQAAAABQGaPetpbNZuPuu++OefPmRW1tbVxwwQVx5MiROHLkSGzYsCFyuVw8+uijMTg4GPv27YvFixfHokWLIpPJRC6Xi87Ozsk4DwAAAAAqYNSZR1/72teKXx86dCheeeWVePbZZ+PNN9+MTZs2RWNjY6xduza2bdsW55xzTmSz2eL45ubmOHr0aGUqBwAAAKDiSnrmUUTEO++8E2vXro277rorvvKVr8Tjjz9efO2GG26Il156Kdrb26Ompqa4vlAonLJcigUL5o86JpttHPH13r6BmFc7t/hfZq7RegGG6BXKoV8olV6hHPqFUukVyqFfmAwlhUd79+6N2267LTZs2BAdHR3x61//Og4dOhTt7e0R8UVIlMlkYuHChZHP54vb5fP5U56JVIpjx7picLBwxvrhH4h8/sSI+8hmGyN3x/Z4+f+uGHUs01c22+j6UhK9Qjn0C6XSK5RDv1AqvUI59AulmDOnpqSJOiPuY7QBH3zwQXz3u9+Nhx9+ODo6OiLii7Do/vvvj08//TT6+vriueeei6uvvjouueSSOHjwYBw+fDgGBgZi586d0dLSMq4CAQAAAKieUWce/fjHP46enp7YvHlzcd2qVavipptuiuuvvz76+/ujra0tli9fHhERmzdvjnXr1kVPT0+0trbG0qVLK1c9AAAAABU1ani0cePG2Lhx41lfW7169RnrlixZEjt27Bh/ZQAAAABU3ai3rXGqxqaGaGxqqHYZAAAAAJOi5L+2xhfq6754yzySDAAAAJgNzDwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEgSHgEAAACQJDwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEgSHgEAAACQJDwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEgSHgEAAACQJDwCAAAAIEl4BAAAAECS8AgAAACApEy1C5gIjU0NUV+Xie6e/jhx/GS1ywEAAACYMWbEzKP6ukzk7tge9XUzIgsDAAAAmDJmRHgEAAAAQGUIjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJMyo86u0biMamhmqXAQAAADBjZKpdwESaVzu32iUAAAAAzCgzauYRAAAAABNryoZHjU0NbkEDAAAAqLIpe9tafd0XpZ2och0AAAAAs9mUnXkEAAAAQPUJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkkoKjx577LHo6OiIjo6OeOihhyIiYs+ePZHL5aKtrS22bNlSHHvgwIFYuXJltLe3x7333hv9/f2VqRwAAACAihs1PNqzZ0/8/Oc/jxdffDFeeuml+I//+I/YuXNnbNiwIZ544onYtWtX7N+/P3bv3h0REXfeeWfcd9998eqrr0ahUIitW7dW/CQAAAAAqIxRw6NsNht33313zJs3L2pra+OCCy6IQ4cOxeLFi2PRokWRyWQil8tFZ2dnvP/++9Hd3R2XXnppRESsXLkyOjs7K34SAAAAAFRGZrQBX/va14pfHzp0KF555ZX4y7/8y8hms8X1zc3NcfTo0fjwww9PWZ/NZuPo0aNlFbRgwfxTlrPZxjPGnG1dSjljy1Gp/VIe14FS6RXKoV8olV6hHPqFUukVyqFfmAyjhkdD3nnnnVi7dm3cddddMXfu3Dh06FDxtUKhEDU1NTE4OBg1NTVnrC/HsWNdMThYKH4A8vkTEXHqB2Jo3ZCRPiynjx2v0+uierLZRteBkugVyqFfKJVeoRz6hVLpFcqhXyjFnDk1Z0zUKXsfpQzau3dv/PVf/3Xccccd8Wd/9mexcOHCyOfzxdfz+Xw0Nzefsf6jjz6K5ubmcRUIAAAAQPWMGh598MEH8d3vfjcefvjh6OjoiIiISy65JA4ePBiHDx+OgYGB2LlzZ7S0tMT5558fdXV1sXfv3oiI2L59e7S0tFT2DAAAAAComFFvW/vxj38cPT09sXnz5uK6VatWxebNm2PdunXR09MTra2tsXTp0oiIePjhh2Pjxo3R1dUVF198caxZs6Zy1QMAAABQUaOGRxs3boyNGzee9bUdO3acse7CCy+Mbdu2jb8yAAAAAKqupGceAQAAADA7CY8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQNKsCY8amxqisamh2mUAAAAATCuZahcwWerrvjjVE1WuAwAAAGA6mTUzjwAAAAAon/AIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkmZ1eNTY1BCNTQ3VLgMAAABgyspUu4Bqqq/74vRPVLkOAAAAgKlqVs88AgAAAGBkwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACCp5PCoq6srli9fHu+9915ERNxzzz3R1tYWK1asiBUrVsRrr70WERF79uyJXC4XbW1tsWXLlspUDQAAAMCkyJQy6O23346NGzfGoUOHiuv2798fzzzzTDQ3NxfXdXd3x4YNG+Lpp5+O8847L9auXRu7d++O1tbWCS8cAAAAgMoraebR1q1bY9OmTcWg6OTJk3HkyJHYsGFD5HK5ePTRR2NwcDD27dsXixcvjkWLFkUmk4lcLhednZ0VPQEAAAAAKqekmUc//OEPT1n+6KOP4sorr4xNmzZFY2NjrF27NrZt2xbnnHNOZLPZ4rjm5uY4evRoWQUtWDD/lOVstvGMMWdbl3L62PHubzzbMPFcB0qlVyiHfqFUeoVy6BdKpVcoh35hMpQUHp1u0aJF8fjjjxeXb7jhhnjppZeivb09ampqiusLhcIpy6U4dqwrBgcLxQ9APn8iIk79QAytGzLSh+X07Ydve7Z1oxnLNlRGNtvoOlASvUI59Aul0iuUQ79QKr1COfQLpZgzp+aMiTpl72MsG/3617+OV199tbhcKBQik8nEwoULI5/PF9fn8/lTnokEAAAAwPQypvCoUCjE/fffH59++mn09fXFc889F1dffXVccsklcfDgwTh8+HAMDAzEzp07o6WlZaJrrpjGpobIZhujsamh2qUAAAAATAljCo8uvPDCuOmmm+L666+Pjo6OuOiii2L58uVRV1cXmzdvjnXr1sWyZcviK1/5SixdunSia66Y+rpM5O7YHvV1Y7qbDwAAAGDGKSslef3114tfr169OlavXn3GmCVLlsSOHTvGX9kU09jUIFQCAAAAZp0xzTyajYZmJUFKY1ODWx4BAACYcUylgQkyNDPN3zoAAABgJjHzCAAAAIAkM49giht63lZ3T3+cOH6y2uUAAAAwy5h5BFOcvwIIAABANc248Ki3b6DaJQAAAADMGDMuPJpXO7faJQAAAADMGDMuPAIAAABg4giPAAAAAEgSHgEAAACQJDwCAAAAIGnW/e3vxqaGqK/LRHdPf7VLAQAAAJjyZt3Mo/q6TOTu2B71dencrLdvIBqbGiaxKgAAAICpadbNPCrFvNq5ERFxosp1AAAAAFTbrJt5BAAAAEDphEcAAAAAJE3J8MjzhgAAAACmhikZHo30MGsAAAAAJs+UDI8AAAAAmBqERwAAAAAkuT9sBI1NDVFfl4nunv5qlwIAAABQFWYejaC+LhO5O7Z7BhMAAAAwawmPAAAAAEgypWaMht/SduL4yWqXM2M0NjVERHhPAQAAYIow82iMxnJLW2NTQzEc4ezq6zJuEwQAAIApxG/pk2goFDlR5ToAAAAASmXmEYzAbDEAAABmOzOPYARmiwEAADDbmXkEAAAAQJLwCAAAAIAk4REAAAAAScKjKpmMBzF72DMAAAAwXh6YXSWT8SBmD3sGAAAAxkt4NEUMzRA6cfxklSs51VStq5Jm4zlTWY1NDVFfl4nunn59BQAATDtuW5si6usyxZlCpZqM29LGUtdoJrruxqaGyGYbi/sd+nqsKnHOzG71dZnI3bFdXwEAANOS8Ggam64hx0TXPfwX83J+SZ+IoImpaTKf9+XZYoyFvgEAYDoRHjFrmQ0yc01msDpdQ1yqS98AADCdCI8AAAAASBIeAQAAAJAkPAIAAAAgSXgEAAAAQJLwCAAAAIAk4REAAAAASdMiPGpsaqh2CQAAAACz0rQIj+rrMtUuAQAAAGBWmhbhEQAAAADVITwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEgSHgEAAACQJDwCAAAAIEl4BAAAAECS8AgAAACAJOERAAAAAEnCIwAAAACSSg6Purq6Yvny5fHee+9FRMSePXsil8tFW1tbbNmypTjuwIEDsXLlymhvb4977703+vv7J75qAAAAACZFSeHR22+/Hddff30cOnQoIiK6u7tjw4YN8cQTT8SuXbti//79sXv37oiIuPPOO+O+++6LV199NQqFQmzdunXMxfX2DUQ22zjm7QEAAAAYn5LCo61bt8amTZuiubk5IiL27dsXixcvjkWLFkUmk4lcLhednZ3x/vvvR3d3d1x66aUREbFy5cro7Owcc3HzaudG7o7tY94eAAAAgPHJlDLohz/84SnLH374YWSz2eJyc3NzHD169Iz12Ww2jh49WlZBCxbMH3VMObORShk73tlN5W4/fPzp246lltG2mYjZW5WYATbSPks93kTsIzV2pOs01prGy0y88oz1Go73WBMxjuqarOukH6Y/15By6BdKpVcoh35hMpQUHp1ucHAwampqisuFQiFqamqS68tx7FjXqAFSPn/ilOWRPixDY8c7ppx6Uob2n8+fOOXr018r1WjbjGWfldhHOfss53jZbOMp7+XpRtvH8O2Gjx3pOpWyv4l8r4bvtxL7nqnO9vmq1HtXynV3DaeXSvbL8GNE6IfpbjJ6hZlDv1AqvUI59AulmDOnpqSJOiPuYywbLVy4MPL5fHE5n89Hc3PzGes/+uij4q1uAAAAAEw/YwqPLrnkkjh48GAcPnw4BgYGYufOndHS0hLnn39+1NXVxd69eyMiYvv27dHS0jKhBQMAAAAwecZ021pdXV1s3rw51q1bFz09PdHa2hpLly6NiIiHH344Nm7cGF1dXXHxxRfHmjVrJrRgAAAAACZPWeHR66+/Xvx6yZIlsWPHjjPGXHjhhbFt27bxVwYAAABA1Y3ptjUAAAAAZgfhEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAUqbaBYxVY1ND1Ndlorunv9qlAAAAAMxY03bmUX1dJnJ3bI/6ummbfwEAAABMedM2PAIAAACg8oRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABA0owOj3r7BqKxqaHaZQAAAABMW5lqF1BJ82rnRkTEiSrXAQAAADBdzeiZRwAAAACMj/AIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgKRQUDMAABIySURBVCThEQAAAABJwiMAAAAAkqZdeNTbNxCNTQ2nLAMAAABQGZlqF1CuebVzR1wGAAAAYOJMu5lHAAAAAEwe4REAAAAAScKj3xv+HCUAAAAAviA8+r36umn3+CcAAACAihMeAQAAAJBkuk2FNTY1RH1dJrp7+qtdCgAAAEDZzDyqsPq6TOTu2O62OAAAAGBaEh4BAAAAkCQ8AgAAACBJeAQAAABAkvAIAAAAgKRxPcX5hhtuiI8//jgymS928/3vfz/efffd+NGPfhT9/f3xV3/1V7F69eoJKRQAAACAyTfm8KhQKMShQ4fiX/7lX4rh0dGjR2P9+vXxwgsvxLx582LVqlVxxRVXxFe/+tUJKxgAAACAyTPm8Oi3v/1tRETceOON8cknn8Sf//mfxx/8wR/ElVdeGeeee25ERLS3t0dnZ2fceuutE1MtzHKNTQ0REXHi+MkqVwIAAMBsMebw6Pjx47FkyZL427/92+jr64s1a9bENddcE9lstjimubk59u3bV9Z+FyyYP9aSkrLZxnG9Pt79jzT+9G3HUkulz2+i9lHOPks93kTsIzV2pOs01prGq77ui49sfQWPMZOM9RqO91gTMY7qmqzrpB+mP9eQcugXSqVXKId+YTKMOTz6xje+Ed/4xjeKy9ddd1088MADccsttxTXFQqFqKmpKWu/x451TXiAlM+fGPEDNdrrpew/5Wz7HX68oW1PXy7FaNuMZZ+V2Ec5+yzneNls44jXbrR9DN9u+NjhNZRbT6ljy5HqIdLO9vmq1HtWynVP9RpTUyX7ZfgxIvTDdDcZvcLMoV8olV6hHPqFUsyZUzPunGXMf23trbfeijfeeKO4XCgU4vzzz498Pl9cl8/no7m5eVwFAgAAAFA9Yw6PTpw4EQ899FD09PREV1dXvPjii/GP//iP8cYbb8THH38cJ0+ejJ/85CfR0tIykfUCAAAAMInGfNvaVVddFW+//XZce+21MTg4GN/+9rfjsssui/Xr18eaNWuir68vrrvuuvj6178+kfUCAAAAMInGHB5FRNx+++1x++23n7Iul8tFLpcbV1EAAAAATA1jvm1tOurtG6h2CQAAAADTyqwKj+bVzq12CQAAAADTyqwKjwAAAAAoj/AIAAAAgCThEQAAAABJwiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8mqEamxqqXQIAAAAwAwiPZqj6uky1SwAAAABmAOERAAAAAEnCIwAAAACShEcAAAAAJAmPAAAAAEia9eFRb99AZLON1S4DAAAAYEqa9eHRvNq5kbtje1WOPRRcNTY1VOX4AAAAAKOZ9eFRJTQ2NZQUCg0FV/V1mUmqDAAAAKA8wqMKqK/LCIUAAACAGUF4BAAAAECS8KiCevsGql0CAAAAwLgIjypoXu3capcAAAAAMC7CoxKYQTQ2jU0N/pIcAAAATHOe6FyCqT6DqLGpIerrMtHd0x8njp+sdjlFQw8MP1HlOgAAAICxM/NoBvDX3QAAAIBKER4BAAAAkGSqygwzdAtbKeMiYkrd5gYAAABMPWYezTBDt7CVMs5tbgAAAMBopAezTKkzk2C66+0biGy2Mbp7+qtdCgAAwLRm5tEsU+rMJJju5tXO9SB5AACACTBrf6vq7RuIebVzq13GlFTO85DKHTtVf5Efqs0sFSqpt28gGpsaTvm8DO89zyADAACmomk586i3b2Dc+xAcpZXzPKRyx07VWU9DtU3VcIuZYV7t3DN6TO8BAABT3bQMj8oJfoaeewIAAABA+aZleFSOoeeeAAAAAFC+GR8eAQAAADB2wiMAAAAAkoRHAAAAACQJjwAAAABIEh4BAAAAkCQ8SujtG6h2CQAAAABVJzxKmFc7t9olAAAAAFSd8AgAAACAJOERAAAAAEnCIwAAAACShEcAAAAAJAmPxsBfYgMAAABmC+HRGAz/S2y9fQPR2NRQtVoEWQAAAEAlZapdwHQ3FCSdqPLxAQAAACrBzCMAAAAAkoRHAAAAACQJjwAAAABI8syjWaKaD/WeaI1NDVFfl/GwcAAAAJgEZh7NEvV1maivmxlZYX1dJnJ3bPewcAAAAJgEMyNNmCF6+wYim22M7p7+OHH8ZLXLGdXQbKbpVvdEGpoF1d3TX+1SAAAAoCLMPJokpdxiNa92buTu2B71dZlobGqIbLaxGNCcvjwVDM1kGl73bDM0C6pa517pvmhsajilB6dS/wEAI/O9G4CJIjyaJOXeYnV6KFHtkIKpqdJ9Mfx2x5l06yMAzAa+dwMwUYRHE2Doti3/ZwcAAACYaYRHE2Dotq05c2rGFCCNdkvb6fsculVpoo8DAAAAcDrh0QSaVzt31KnBQ7OUTt9uJKfvc+hWpVIMP95Y/zpZb9+AWVUAAAAwS1UkPHr55Zdj2bJl0dbWFs8++2wlDjFtDc1Smk7HKyUUAwAAAGamCU8Ejh49Glu2bIkXXngh5s2bF6tWrYorrrgivvrVr070oaak3r6BMc/wmch9jMXQn50fqmH4DKmh5aE/ST9amDQ0U+n07c52vJ7egSgUCnHi+Mmy6h1pRlRv30A0/a9zivsdGjf869H2PZZbA8dieG0jGa0vSt3PTDdTZ8mNdn2HPk/dPf1j6oHx9M94tx1P3UDl+L4C5fN9DZipJjw82rNnT1x55ZVx7rnnRkREe3t7dHZ2xq233lrS9nPm1Jyy3PylhrN+PVGvTfQxhn65H88+z7aPoeWhAGEizncoIOn5fbBTV5eJ//ODn8SPN7bFvNq5xa+Hzuv//OAn8aPv/e8zXhteW1NTQ3R1dRfDpdPHDj92/bDjRUR8NuzaD++D+fPro+73IVMUCqe8T0PPcTr9/IeHLJ/NqSnWM/zrs2039P4Or7v4Pv3++F1d3SO+v3Pm1MT8+fUREdHV1V38eug97un9oua6eXOjp6c/6obVdrqhbU8/p+Hvz9Dx60/bT/F96+kv1jG0XKzl96+dfrzTz3HOadcmNW4sRtvX6ecxmtT1Lbfu08fOn18fUVNTvG7D9zG891NOr+Vsr52+/mzndbY+GXp9qGdTY0ZSX5dJ9vpo79totQ05236G6v7R9/538T0863s/wvEnWinXM6XUfh4y0jU/23YjfX7HUut49jNZ12W8dZZ7rIjyzqnUazhepdQ20e9VqZ/tyahlphhPv4znPZ2T+NlgNpmsf7PG+/14yGT928LMMNn9MlGfp9N/z5tt/y5NponokZpC4fe/jU+Qf/qnf4rPP/881q9fHxERzz//fOzbty/+4R/+YSIPAwAAAMAkmPBnHg0ODkZNzf9PtQqFwinLAAAAAEwfEx4eLVy4MPL5fHE5n89Hc3PzRB8GAAAAgEkw4eHRn/zJn8Qbb7wRH3/8cZw8eTJ+8pOfREtLy0QfBgAAAIBJMOEPzP7DP/zDWL9+faxZsyb6+vriuuuui69//esTfRgAAAAAJsGEPzAbAAAAgJljwm9bAwAAAGDmEB4BAAAAkCQ8AgAAACBJeAQAAABA0pQJj15++eVYtmxZtLW1xbPPPlvtcpgiurq6Yvny5fHee+9FRMSePXsil8tFW1tbbNmypTjuwIEDsXLlymhvb4977703+vv7q1UyVfDYY49FR0dHdHR0xEMPPRQReoW0Rx55JJYtWxYdHR3x5JNPRoR+YWQPPvhg3H333RGR7okjR47E6tWrY+nSpXHLLbfEZ599Vs2SqYIbbrghOjo6YsWKFbFixYp4++23kz/fpv7NYXZ4/fXXY+XKlXHNNdfED37wg4jwfYize/7554v/pqxYsSIuu+yy+P73v69fOKvt27cXfyd68MEHI2KCf24pTAH/8z//U7jqqqsKv/vd7wqfffZZIZfLFd55551ql0WV/fu//3th+fLlhYsvvrjw3//934WTJ08WWltbC++++26hr6+vcOONNxZ+9rOfFQqFQqGjo6Pwb//2b4VCoVC45557Cs8++2w1S2cS/eIXvyj8xV/8RaGnp6fQ29tbWLNmTeHll1/WK5zVv/7rvxZWrVpV6OvrK5w8ebJw1VVXFQ4cOKBfSNqzZ0/hiiuuKHzve98rFArpnrjpppsKO3fuLBQKhcJjjz1WeOihh6pTMFUxODhY+Na3vlXo6+srrkv9fDvSzzPMfO+++27hW9/6VuGDDz4o9Pb2Fq6//vrCz372M9+HGNV//dd/Fa6++urCkSNH9Atn+Pzzzwvf/OY3C8eOHSv09fUVrrvuusIvfvGLCf25ZUrMPNqzZ09ceeWVce6558Y555wT7e3t0dnZWe2yqLKtW7fGpk2borm5OSIi9u3bF4sXL45FixZFJpOJXC4XnZ2d8f7770d3d3dceumlERGxcuVK/TOLZLPZuPvuu2PevHlRW1sbF1xwQRw6dEivcFaXX355PPXUU5HJZOLYsWMxMDAQx48f1y+c1SeffBJbtmyJm2++OSIi2RN9fX3xq1/9Ktrb209Zz+zx29/+NiIibrzxxvjTP/3TeOaZZ5I/36Z+nmF2eO2112LZsmWxcOHCqK2tjS1btkRDQ4PvQ4zq7/7u72L9+v/Xzh2FNNWHcRz/rW1IYV2srMkIIggMKYkkOCUOo0TZhRJemBdCIRFEi91IhNSVJSZdCOKV1FUYERWIhWBdaA5KL/IijIiURVKLJBV1m2fnvYgOlDu98bI39777fu7+h138Bz/+z3OenbOIYrEYecEapmkqnU5reXlZq6urWl1dlcfjyWrfkhPDo0+fPqmoqMheb9++XR8/flzHHSEXtLe3q7y83F475eTn60VFReQnj+zZs8c+EKenp/Xo0SO5XC6yAkder1fd3d0KhUIyDIOzBY4uX76sSCSiLVu2SFpbh75nYm5uToWFhfJ4PD9cR/6Yn5+XYRjq6enRrVu31N/frw8fPvzW2ULfm19mZmZkmqbOnj2ruro63b59mzqEvzU2NqaVlRXV1taSF2RUWFioCxcuqLa2VsFgUIFAQF6vN6t9S04Mj9LptFwul722LOuHNSA554T8QJLevHmj06dPq7W1VTt37iQr+KVwOKxoNKrZ2VlNT0+TF6xx9+5dFRcXyzAM+5pTJjJlg6zklwMHDqizs1ObN2+Wz+dTQ0ODuru7OVuwhmmaikajunr1qu7cuaPJyUnFYjGygl/q7+/XqVOnJHFPhMympqZ07949PX36VCMjI9qwYYOePXuW1b7Fk/Vd/wN+v1/j4+P2Oh6P268qAd/5/X7F43F7/T0nP1///Pkz+ckzExMTCofDunTpkkKhkJ4/f05WkNHbt2+VTCa1d+9ebdy4UdXV1Xr8+LHcbrf9GfICSRocHFQ8HlddXZ2+fv2qpaUluVyujJnw+XxaWFiQaZpyu930MXlofHxcqVTKHjZalqVAIPBbtYi85Jdt27bJMAz5fD5J0rFjx6hD+KVkMqkXL16oo6NDEvdEyGx0dFSGYWjr1q2Svr2K1tfXl9W+JSeePDp8+LCi0ai+fPmi5eVlDQ0NqbKycr23hRxTVlamd+/e2Y/7DgwMqLKyUoFAQAUFBZqYmJD07V/myU/+mJ2d1blz59TV1aVQKCSJrMDZ+/fv1dbWpmQyqWQyqeHhYTU2NpIXrHHz5k0NDAzo4cOHCofDOnr0qK5du5YxE16vV+Xl5RocHJQkPXjwgKzkmYWFBXV2diqRSGhxcVH379/X9evXM/a3TjUK+aGqqkqjo6Oan5+XaZoaGRlRTU0NdQiOXr9+rV27dmnTpk2S6HORWUlJicbGxrS0tCTLsvTkyRMdOnQoq31LTjx5tGPHDkUiETU3NyuVSqmhoUH79+9f720hxxQUFKijo0Pnz59XIpFQMBhUTU2NJKmrq0ttbW1aXFxUaWmpmpub13m3+FP6+vqUSCTsX2MkqbGxkawgo2AwqMnJSdXX18vtdqu6ulqhUEg+n4+84Lc4ZeLKlSu6ePGient7VVxcrBs3bqzzTvEnVVVV6eXLl6qvr1c6nVZTU5MOHjzo2N861Sj8/5WVlamlpUVNTU1KpVI6cuSITp48qd27d1OHkFEsFpPf77fX3BMhk4qKCr169UonTpyQ1+vVvn37dObMGR0/fjxrfYvLsizr3/4iAAAAAAAA+G/KidfWAAAAAAAAkJsYHgEAAAAAAMARwyMAAAAAAAA4YngEAAAAAAAARwyPAAAAAAAA4IjhEQAAAAAAABwxPAIAAAAAAIAjhkcAAAAAAABw9Bfx0OYOvPWiWAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# concat file to sentences\n",
    "concat_train_data = concat_files_to_sentence(expanded_train_df[\"Files\"])\n",
    "concat_test_data = concat_files_to_sentence(test_df[\"Files\"])\n",
    "print(concat_train_data[1])\n",
    "\n",
    "# plot distribution\n",
    "max_seqlength, sequence_list = get_seqlength(concat_train_data)\n",
    "print(\"<sample training data>: \", training_data[1])\n",
    "print('max length: %d'%max_seqlength)\n",
    "plot_hist(sequence_list)\n",
    "\n",
    "# getting file threshold\n",
    "threshold = 0.6\n",
    "number_of_actions = [len(item.split()) for item in concat_train_data]\n",
    "length_threshold = get_file_threshold(number_of_actions, threshold)\n",
    "print(\"length threshold %d\"%length_threshold)\n",
    "\n",
    "# filter data\n",
    "expanded_train_df = expanded_train_df.drop([\"Files\"], axis=1)\n",
    "test_df = test_df.drop([\"Files\"], axis=1)\n",
    "expanded_train_df[\"Files\"] = concat_train_data \n",
    "test_df[\"Files\"] = concat_test_data \n",
    "\n",
    "# filter too long commits\n",
    "expanded_train_df['len_seq'] = expanded_train_df.apply(lambda row: len(row['Files'].split()), axis = 1)\n",
    "test_df['len_seq'] = test_df.apply(lambda row: len(row['Files'].split()), axis = 1)\n",
    "expanded_train_df = expanded_train_df[expanded_train_df['len_seq'] <= length_threshold].reset_index(drop = True)\n",
    "test_df = test_df[test_df['len_seq'] <= length_threshold].reset_index(drop = True)\n",
    "print(test_df.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "expanded_train_df['len_seq'] = expanded_train_df.apply(lambda row: len(row['Files'].strip()), axis = 1)\n",
    "test_df['len_seq'] = test_df.apply(lambda row: len(row['Files'].strip()), axis = 1)\n",
    "expanded_train_df = expanded_train_df[expanded_train_df['len_seq'] != 0].reset_index(drop = True)\n",
    "test_df = test_df[test_df['len_seq'] != 0].reset_index(drop = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  Tokenize and Pad data and get embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-21T03:27:53.966249Z",
     "start_time": "2019-07-21T03:27:47.781Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(4165, 31)\n",
      "(4355, 31)\n",
      "[2, 2, 17, 121]\n",
      "(4355, 43)\n",
      "length of vocabulary:338\n",
      "[1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0]\n",
      "(4165, 43)\n",
      "(190, 43)\n",
      "(4165, 3)\n",
      "(190, 3)\n"
     ]
    }
   ],
   "source": [
    "# padding data\n",
    "train_test_split_number = expanded_train_df.shape[0]\n",
    "print(expanded_train_df.shape)\n",
    "df_for_tokenize = pd.concat([expanded_train_df,test_df], axis = 0)\n",
    "print(df_for_tokenize.shape)\n",
    "\n",
    "#Training \n",
    "docs = df_for_tokenize['Files'].values\n",
    "t = Tokenizer(filters = '', lower=False)\n",
    "t.fit_on_texts(docs)\n",
    "\n",
    "sequences = t.texts_to_sequences(docs)\n",
    "print(sequences[0])\n",
    "\n",
    "#Pad training data \n",
    "padded_seq = pad_sequences(sequences, maxlen=length_threshold + 1, padding=\"post\", truncating=\"post\")\n",
    "print(padded_seq.shape)\n",
    "\n",
    "vocabulary = t.word_index \n",
    "vocabulary_inv = dict((v, k) for k, v in vocabulary.items())\n",
    "vocabulary_inv[0] = \"<PAD/>\"\n",
    "print('length of vocabulary:%d'%len(vocabulary_inv.keys()))\n",
    "\n",
    "# split train and test set\n",
    "X_train = padded_seq[0:train_test_split_number]\n",
    "X_test = padded_seq[train_test_split_number:]\n",
    "\n",
    "target_col =  ['Adaptive','Perfective','Implementation']\n",
    "y_train = expanded_train_df[target_col].values\n",
    "y_test = test_df[target_col].values\n",
    "\n",
    "print(X_train[10, :])\n",
    "print(X_train.shape)\n",
    "print(X_test.shape)\n",
    "print(y_train.shape)\n",
    "print(y_test.shape)\n",
    "\n",
    "# get embedding\n",
    "pre_embed = load_embedding(\"embedding_genism_64_dic.txt\")\n",
    "\n",
    "embedding_weights = dict()\n",
    "for key in range(0, len(vocabulary_inv.keys())):\n",
    "    embedding_weights[key] = pre_embed[vocabulary_inv[key]]\n",
    "\n",
    "# X_train = np.stack([np.stack([pre_embed[vocabulary_inv_train[action]] for action in commit]) for commit in X_train])\n",
    "# X_test = np.stack([np.stack([pre_embed[vocabulary_inv_test[action]] for action in commit]) for commit in X_test])\n",
    "# print(\"x_train static shape:\", X_train.shape)\n",
    "# print(\"x_test static shape:\", X_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### CNN for text pytorch"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "import os\n",
    "import datetime\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "import torch.autograd as autograd\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from model.CNN import CNN_Text\n",
    "from train_model import train, eval, print_evaluation_scores\n",
    "from dataloader import CodeChangeDataset, ToTensor"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "class Args:\n",
    "    def __init__(self, parameters):\n",
    "        # model parameters\n",
    "        self.lr = parameters['lr'] if parameters.get('lr') != None else 0.001\n",
    "        self.epochs = parameters['epoch'] if parameters.get('epoch') != None else 10\n",
    "        self.batch_size = parameters['batch_size'] if parameters.get('batch_size') != None else 64\n",
    "        self.shuffle = parameters['shuffle'] if parameters.get('shuffle') != None else False                     # whether to shuffle data after every epoch\n",
    "        self.dropout = parameters['dropout'] if parameters.get('dropout') != None else 0.5\n",
    "        self.max_norm = parameters['l2-norm'] if parameters.get('l2-norm') != None else 3.0                      # l2 norm\n",
    "        self.embed_dim = parameters['embed_dim'] if parameters.get('embed_dim') != None else 64                 # embedding dimension\n",
    "        self.embed_num = parameters['embed_num'] if parameters.get('embed_num') != None else 5000               # number of filters for each conv\n",
    "        self.kernel_num = parameters['kernel_num'] if parameters.get('kernel_num') != None else 10               # number of filters for each conv\n",
    "        self.kernel_sizes = parameters['kernel_sizes'] if parameters.get('kernel_sizes') != None else [3,4,5]    # list of kernel sizes\n",
    "        self.class_num = parameters['class_num'] if parameters.get('class_num') != None else 3\n",
    "        self.pool_size = parameters['pool_size'] if parameters.get('pool_size') != None else 2\n",
    "        self.static = parameters['static'] if parameters.get('static') != None else True\n",
    "        self.embed_weights = None\n",
    "        \n",
    "        # training precocess parameters\n",
    "        self.log_interval = parameters['log_interval'] if  parameters.get('log_interval') != None else 1\n",
    "        self.test_interval = parameters['test_interval'] if  parameters.get('test_interval') != None else 10\n",
    "        self.save_interval = parameters['save_interval'] if  parameters.get('save_interval') != None else 100\n",
    "        self.save_dir = parameters['save_dir'] if  parameters.get('save_dir') != None else './'\n",
    "        self.early_stop = parameters['early_stop'] if  parameters.get('early_stop') != None else 3000\n",
    "        self.save_best = parameters['save_best'] if  parameters.get('save_best') != None else True\n",
    "        self.no_cuda = parameters['no_cuda'] if  parameters.get('no_cuda') != None else False            # wether to use gpu\n",
    "        self.device = parameters['device'] if  parameters.get('device') != None else -1                 # which device to use -1 means cpu\n",
    "        self.cuda = True"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "def main():\n",
    "    # REPRODUCIBILITY\n",
    "    torch.manual_seed(0)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    np.random.seed(0)\n",
    "    \n",
    "    vocab_size = len(vocabulary_inv.keys())\n",
    "    \n",
    "    # Parameters\n",
    "    parameters = {'class_num':3,\n",
    "                  'embed_dim':64,\n",
    "                  'epoch':80, \n",
    "                  'batch_size':256, \n",
    "                  'device':0,\n",
    "                  'lr':0.001, \n",
    "                  'shuffle':False,\n",
    "                  'dropout':0.5, \n",
    "                  'l2-norm':  3.0, \n",
    "                  'embed_num': vocab_size,\n",
    "                  'kernel_num':600, \n",
    "                  'kernel_sizes':[4,4,4,4],\n",
    "                  'pool_size':2,\n",
    "                  'static':True\n",
    "                 }\n",
    "    args = Args(parameters)\n",
    "\n",
    "    # change dir\n",
    "    args.save_dir = os.path.join(args.save_dir, datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S'))\n",
    "    # check gpu avialiable\n",
    "    args.cuda = (not args.no_cuda) and torch.cuda.is_available()\n",
    "    print(args.cuda)\n",
    "    # pretrained embedding weights\n",
    "    args.embed_weights = torch.from_numpy(np.array([v for v in embedding_weights.values()])).float()\n",
    "    \n",
    "    # data loader\n",
    "    train_data = CodeChangeDataset(X_train, y_train, transform = ToTensor())\n",
    "    test_data = CodeChangeDataset(X_test, y_test, transform = ToTensor())\n",
    "\n",
    "    train_dataloader = DataLoader(train_data, batch_size=args.batch_size,shuffle=True, num_workers=0)\n",
    "    test_dataloader = DataLoader(test_data, batch_size=args.batch_size, shuffle = False, num_workers=0)\n",
    "\n",
    "    # model\n",
    "    model = CNN_Text(args)\n",
    "    # if args.snapshot is not None:\n",
    "    #     print('\\nLoading model from {}...'.format(args.snapshot))\n",
    "    #     cnn.load_state_dict(torch.load(args.snapshot))\n",
    "\n",
    "    if args.cuda:\n",
    "        torch.cuda.set_device(args.device)\n",
    "        model = model.cuda()\n",
    "\n",
    "    try:\n",
    "        for epoch in range(args.epochs):\n",
    "            train_loss, train_acc = train(train_dataloader, model, args, 'CNN')\n",
    "            val_loss, val_acc = eval(test_dataloader, model, args,'CNN')\n",
    "            print(f'Epoch: {epoch + 1:02} -- Train Loss: {train_loss:.3f} Train Acc: {train_acc:.2f}%    Val. Loss: {val_loss:3f} Val. Acc: {val_acc:.2f}%')\n",
    "    \n",
    "    except KeyboardInterrupt:\n",
    "        print('\\n' + '-' * 89)\n",
    "        print('Exiting from training early')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "best_acc = 0\n",
    "last_step = 0\n",
    "# evaluation on validation set\n",
    "    dev_acc = eval(val_dataloader, model, args)\n",
    "    if dev_acc > best_acc:\n",
    "        best_acc = dev_acc\n",
    "        last_step = steps\n",
    "#                     if args.save_best:\n",
    "#                         save(model, args.save_dir, 'best', steps)\n",
    "    else:\n",
    "        if steps - last_step >= args.early_stop:\n",
    "            print('early stop by {} steps.'.format(args.early_stop))\n",
    "            #return best_acc\n",
    "#             elif steps % args.save_interval == 0:\n",
    "#                 save(model, args.save_dir, 'snapshot', steps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### RNN for text classification"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import datetime\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.autograd import Variable\n",
    "import torch.autograd as autograd\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "#from model.GRU import SimpleGRU\n",
    "from train_model import train, eval, print_evaluation_scores\n",
    "from dataloader import CodeChangeDataset, ToTensor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "from torch.nn import functional as F\n",
    "from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence\n",
    "\n",
    "class RCNN(nn.Module):\n",
    "    def __init__(self, args):\n",
    "        super(RCNN, self).__init__()\n",
    "        \n",
    "        \"\"\"\n",
    "        Arguments\n",
    "        ---------\n",
    "        batch_size : Size of the batch which is same as the batch_size of the data returned by the TorchText BucketIterator\n",
    "        output_size : 2 = (pos, neg)\n",
    "        hidden_sie : Size of the hidden_state of the LSTM\n",
    "        vocab_size : Size of the vocabulary containing unique words\n",
    "        embedding_length : Embedding dimension of GloVe word embeddings\n",
    "        weights : Pre-trained GloVe word_embeddings which we will use to create our word_embedding look-up table \n",
    "        \"\"\"\n",
    "        self.output_size = args.n_out\n",
    "        self.hidden_size = args.n_hidden\n",
    "        self.vocab_size = args.vocab_size\n",
    "        self.embedding_dim = args.embedding_dim\n",
    "        \n",
    "        self.word_embeddings = nn.Embedding(self.vocab_size, self.embedding_dim)            # Initializing the look-up table.\n",
    "        # self.word_embeddings.weight = nn.Parameter(args.weights, requires_grad=False) # Assigning the look-up table to the pre-trained GloVe word embedding.\n",
    "        self.dropout = 0.2\n",
    "        self.lstm = nn.LSTM(self.embedding_dim, self.hidden_size, dropout=0, bidirectional=True)\n",
    "        self.W2 = nn.Linear(2* self.hidden_size+self.embedding_dim, self.hidden_size)\n",
    "        self.label = nn.Linear(self.hidden_size, self.output_size)\n",
    "\n",
    "    def forward(self, input_sentence):\n",
    "    \n",
    "        \"\"\" \n",
    "        Parameters\n",
    "        ----------\n",
    "        input_sentence: input_sentence of shape = (batch_size, num_sequences)\n",
    "        batch_size : default = None. Used only for prediction on a single sentence after training (batch_size = 1)\n",
    "        \n",
    "        Returns\n",
    "        -------\n",
    "        Output of the linear layer containing logits for positive & negative class which receives its input as the final_hidden_state of the LSTM\n",
    "        final_output.shape = (batch_size, output_size)\n",
    "        \"\"\"\n",
    "        \n",
    "        \"\"\"\n",
    "        The idea of the paper \"Recurrent Convolutional Neural Networks for Text Classification\" is that we pass the embedding vector\n",
    "        of the text sequences through a bidirectional LSTM and then for each sequence, our final embedding vector is the concatenation of \n",
    "        its own GloVe embedding and the left and right contextual embedding which in bidirectional LSTM is same as the corresponding hidden\n",
    "        state. This final embedding is passed through a linear layer which maps this long concatenated encoding vector back to the hidden_size\n",
    "        vector. After this step, we use a max pooling layer across all sequences of texts. This converts any varying length text into a fixed\n",
    "        dimension tensor of size (batch_size, hidden_size) and finally we map this to the output layer.\n",
    "        \"\"\"\n",
    "        \n",
    "        input = self.word_embeddings(input_sentence) # embedded input of shape = (num_sequences, batch_size, embedding_length)\n",
    "        input = input.permute(1, 0, 2) # input.size() = (num_sequences, batch_size, embedding_length)\n",
    "        h_0, c_0 = self.init_hidden(input_sentence.size(0))\n",
    "\n",
    "        output, (final_hidden_state, final_cell_state) = self.lstm(input, (h_0, c_0))\n",
    "        \n",
    "        final_encoding = torch.cat((output, input), 2).permute(1, 0, 2)\n",
    "        y = self.W2(final_encoding) # y.size() = (batch_size, num_sequences, hidden_size)\n",
    "        y = F.max_pool1d(y, y.size()[2]) # y.size() = (batch_size, hidden_size, 1)\n",
    "        y = y.squeeze(2)\n",
    "        outp = self.label(y)\n",
    "        \n",
    "        return F.log_softmax(outp, dim=-1)\n",
    "\n",
    "    def init_hidden(self, batch_size):\n",
    "        h = Variable(torch.zeros((2, batch_size, self.hidden_size),device=torch.device(\"cuda\")))\n",
    "        c = Variable(torch.zeros((2, batch_size, self.hidden_size),device=torch.device(\"cuda\")))\n",
    "        return h,c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Args:\n",
    "     def __init__(self):\n",
    "        self.vocab_size = None\n",
    "        self.embedding_dim = None\n",
    "        self.n_hidden = None\n",
    "        self.n_out = None\n",
    "        self.num_layers = None\n",
    "        self.lr = None\n",
    "        self.batch_size = None\n",
    "        self.cude = None\n",
    "        self.epochs = None\n",
    "        self.embed_weights = None\n",
    "        self.device = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "ename": "RuntimeError",
     "evalue": "size mismatch, m1: [256 x 43], m2: [300 x 3] at C:/w/1/s/windows/pytorch/aten/src\\THC/generic/THCTensorMathBlas.cu:268",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-149-9a4499b2360e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     47\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     48\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0m__name__\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'__main__'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 49\u001b[1;33m     \u001b[0mmain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-149-9a4499b2360e>\u001b[0m in \u001b[0;36mmain\u001b[1;34m()\u001b[0m\n\u001b[0;32m     38\u001b[0m     \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     39\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mepoch\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mepochs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 40\u001b[1;33m             \u001b[0mtrain_loss\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mtrain_acc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtrain\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtrain_dataloader\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'RCNN'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     41\u001b[0m             \u001b[0mval_loss\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mval_acc\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0meval\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mtest_dataloader\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'RCNN'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     42\u001b[0m             \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'Epoch: {epoch + 1:02} -- Train Loss: {train_loss:.3f} Train Acc: {train_acc:.2f}%    Val. Loss: {val_loss:3f} Val. Acc: {val_acc:.2f}%'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32mD:\\Research\\Text classification Pytorch\\train_model.py\u001b[0m in \u001b[0;36mtrain\u001b[1;34m(dataloader, model, args, model_sign)\u001b[0m\n\u001b[0;32m     93\u001b[0m             \u001b[0moutput\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfeature\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mlength\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcpu\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnumpy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     94\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 95\u001b[1;33m             \u001b[0moutput\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfeature\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     96\u001b[0m         \u001b[0m_\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mpredicted\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moutput\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     97\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\torch\\nn\\modules\\module.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *input, **kwargs)\u001b[0m\n\u001b[0;32m    491\u001b[0m             \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    492\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 493\u001b[1;33m             \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    494\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    495\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-147-f66b961c285f>\u001b[0m in \u001b[0;36mforward\u001b[1;34m(self, input_sentence)\u001b[0m\n\u001b[0;32m     64\u001b[0m         \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mF\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmax_pool1d\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msize\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# y.size() = (batch_size, hidden_size, 1)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     65\u001b[0m         \u001b[0my\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msqueeze\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 66\u001b[1;33m         \u001b[0moutp\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlabel\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     67\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     68\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlog_softmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0moutp\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdim\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\torch\\nn\\modules\\module.py\u001b[0m in \u001b[0;36m__call__\u001b[1;34m(self, *input, **kwargs)\u001b[0m\n\u001b[0;32m    491\u001b[0m             \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_slow_forward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    492\u001b[0m         \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 493\u001b[1;33m             \u001b[0mresult\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mforward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    494\u001b[0m         \u001b[1;32mfor\u001b[0m \u001b[0mhook\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_forward_hooks\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    495\u001b[0m             \u001b[0mhook_result\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mhook\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mresult\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\torch\\nn\\modules\\linear.py\u001b[0m in \u001b[0;36mforward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m     90\u001b[0m     \u001b[1;33m@\u001b[0m\u001b[0mweak_script_method\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     91\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mforward\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 92\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mF\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlinear\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mweight\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mbias\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     93\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     94\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mextra_repr\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\AppData\\Roaming\\Python\\Python37\\site-packages\\torch\\nn\\functional.py\u001b[0m in \u001b[0;36mlinear\u001b[1;34m(input, weight, bias)\u001b[0m\n\u001b[0;32m   1404\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdim\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m2\u001b[0m \u001b[1;32mand\u001b[0m \u001b[0mbias\u001b[0m \u001b[1;32mis\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[1;32mNone\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1405\u001b[0m         \u001b[1;31m# fused op is marginally faster\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1406\u001b[1;33m         \u001b[0mret\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mtorch\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0maddmm\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbias\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mweight\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1407\u001b[0m     \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1408\u001b[0m         \u001b[0moutput\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0minput\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mweight\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mRuntimeError\u001b[0m: size mismatch, m1: [256 x 43], m2: [300 x 3] at C:/w/1/s/windows/pytorch/aten/src\\THC/generic/THCTensorMathBlas.cu:268"
     ]
    }
   ],
   "source": [
    "def main():\n",
    "    # REPRODUCIBILITY\n",
    "    torch.manual_seed(0)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    np.random.seed(0)\n",
    "    \n",
    "    vocab_size = len(vocabulary_inv.keys())\n",
    "    args = Args()\n",
    "    \n",
    "    # Parameters\n",
    "    args.vocab_size = vocab_size \n",
    "    args.embedding_dim = 64 \n",
    "    args.n_hidden = 300 \n",
    "    args.n_out = 3\n",
    "    args.num_layers = 1\n",
    "    args.lr = 0.001\n",
    "    args.batch_size = 256\n",
    "    args.cuda = True\n",
    "    args.epochs = 50\n",
    "    args.device = 0\n",
    "    args.weights = torch.from_numpy(np.array([v for v in embedding_weights.values()])).float()\n",
    "    \n",
    "    # data loader\n",
    "    train_data = CodeChangeDataset(X_train, y_train, transform = ToTensor())\n",
    "    test_data = CodeChangeDataset(X_test, y_test, transform = ToTensor())\n",
    "\n",
    "    train_dataloader = DataLoader(train_data, batch_size=args.batch_size,shuffle=True, num_workers=0)\n",
    "    test_dataloader = DataLoader(test_data, batch_size=args.batch_size, shuffle = False, num_workers=0)\n",
    "\n",
    "    # model\n",
    "    model = RCNN(args)\n",
    "    \n",
    "    if args.cuda:\n",
    "        torch.cuda.set_device(args.device)\n",
    "        model = model.cuda()\n",
    "\n",
    "    try:\n",
    "        for epoch in range(args.epochs):\n",
    "            train_loss, train_acc = train(train_dataloader, model, args, 'RCNN')\n",
    "            val_loss, val_acc = eval(test_dataloader, model, args,'RCNN')\n",
    "            print(f'Epoch: {epoch + 1:02} -- Train Loss: {train_loss:.3f} Train Acc: {train_acc:.2f}%    Val. Loss: {val_loss:3f} Val. Acc: {val_acc:.2f}%')\n",
    "    \n",
    "    except KeyboardInterrupt:\n",
    "        print('\\n' + '-' * 89)\n",
    "        print('Exiting from training early')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}