Thesis Script.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Thesis: An Analysis of Political Sentiment and the Role of Fake Accounts among Twitter Election Messages "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Install packages if not present already\n",
    "#pip install twitterscraper\n",
    "#pip install botometer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO: {'User-Agent': 'Mozilla/5.0 (compatible, MSIE 11, Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko', 'X-Requested-With': 'XMLHttpRequest'}\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from twitterscraper import query_tweets\n",
    "import datetime as dt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import nltk\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import re\n",
    "from string import punctuation\n",
    "\n",
    "import glob\n",
    "import os\n",
    "from pathlib import Path\n",
    "\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from keras.callbacks import EarlyStopping\n",
    "from keras.models import Sequential, Model\n",
    "from keras.layers.core import Activation, Dense\n",
    "from keras.layers import Dropout, GlobalMaxPooling1D, Conv1D\n",
    "from keras.layers.embeddings import Embedding\n",
    "from keras.preprocessing.text import Tokenizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## User Defined functions\n",
    "### All functions written for this script"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function for retrive tweets using Twitterscraper\n",
    "# paramters passed: list of keywords, begin and end date, language\n",
    "def getTweets(keywords,startDate,endDate,lang):\n",
    "    #Create new dataframe for storing tweets\n",
    "    finalDF = pd.DataFrame()\n",
    "    #Loop through keywords to get tweets as each query term\n",
    "    for term in keywords:\n",
    "        tweets = query_tweets(term, begindate = startDate, enddate = endDate, lang=lang)\n",
    "        df = pd.DataFrame(t.__dict__ for t in tweets)\n",
    "        finalDF = electionTweets2019.append(df)\n",
    "    \n",
    "    return finalDF\n",
    "\n",
    "# function to preprocess the tweets\n",
    "# \n",
    "def pre_process(text):\n",
    "    sentence = re.sub(r'<[^>]+>', ' ', text)\n",
    "    sentence = re.sub('[^a-zA-Z]', ' ', sentence)\n",
    "    sentence = re.sub(r\"\\s+[a-zA-Z]\\s+\", ' ', sentence)\n",
    "    sentence = re.sub(r'\\s+', ' ', sentence)\n",
    "    sentence = re.sub(r'#\\S+|@\\S+', ' ', sentence)\n",
    "    sentence = sentence.lower()\n",
    "    return sentence\n",
    "\n",
    "# function to repeat words in full caps \n",
    "def repeatCapitalWords(text):\n",
    "    t = \" \".join(re.findall(r\"\\b[A-Z\\s]+\\b\", text))\n",
    "    return text + t\n",
    "\n",
    "# function to categorize tweets based on party keywords\n",
    "def categorize(text):\n",
    "    text = text.lower()\n",
    "    category = \"BJP\"\n",
    "    # declaring keywords for each party\n",
    "    BJP = [\"bjp4india\",\"bharatiya janata party\",\"bjp\",\"nda \",\"narendra\",\"narendramodi\",\"namo\",\"modi\"]\n",
    "    INC = [\"incindia\",\"cong \",\"congress\",\"inc \",\"upa \",\"rahul gandhi\",\"rahulgandhi\",\"raga\",\"gandhi\"]\n",
    "    \n",
    "    if any(x in text for x in BJP):\n",
    "        if any(x in text for x in INC):\n",
    "            category = \"Both\"\n",
    "    elif any(x in text for x in INC):\n",
    "        category = \"Congress\"\n",
    "    else:\n",
    "        category = \"None\"\n",
    "            \n",
    "    return category\n",
    "\n",
    "# fuction to use botomter to get bot score for each account\n",
    "def getBotScore(id):\n",
    "    try:\n",
    "        result = bom.check_account(id)['scores']['universal']\n",
    "    except:\n",
    "        result = np.nan\n",
    "    \n",
    "    return result\n",
    "\n",
    "# Function to assign account type based on bot score\n",
    "# Simple Bot: Greater than/equal to 0.8\n",
    "# Human-like Bots: Between 0.4 and 0.8\n",
    "# Human: Less than 0.4\n",
    "\n",
    "def checkBotStatus(score):\n",
    "    status = 'Human'\n",
    "    \n",
    "    if score >= 0.8:\n",
    "        status = 'Simple Bot'\n",
    "    elif 0.4 < score < 0.8:\n",
    "        status = 'Human-like Bot'\n",
    "    elif math.isnan(score):\n",
    "        status = 'Suspended'\n",
    "        \n",
    "    return status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Keywords"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we set the keywords for the three different categories of hashtags: \n",
    "#Generic election, candiate specific and party specific\n",
    "\n",
    "# Generic Hashtgas used \n",
    "electionKeywords = ['#2019LokSabhaElections',  '#2019LokSabhapolls', '#2019OpinionPoll', \n",
    "                    '#BattleOf2019', '#ButtonDabaoDeshBanao', \n",
    "                    '#CountingDay',\n",
    "                    '#Election2019', '#ElectionCommission', '#ElectionCommissioner', '#ElectionDirtyCash', '#ElectionResults2019', '#ElectionWar2019', '#Elections2019', '#ElectionAlert','#ElectionDay', '#ElectionSuperT20', '#ElectionUpdate', '#ElectionsOnMyPlate', '#ExitPoll', '#ExitPoll2019', '#ExitPoll2019Results', '#ExitPollPhobia', '#ExitPolls',\n",
    "                    '#GeneralElections', '#GeneralElections2019', \n",
    "                    '#India2019', '#IndiaElects', '#IndiaVotes', '#IndiaElections', '#IndianElections2019', '#Indiavotes', '#LokSabha2019','#IndiaElections2019' , '#IndiaDecides2019'\n",
    "                    '#LokSabhaChunav2019','#LokSabhaElection2019', '#LokSabhaElectionResults', '#LokSabhaElections', '#LokSabhaElections2019', '#LokSabhaPolls2019', '#Loksabha2019', \n",
    "                    '#LoksabhaElections2019', '#LoksabhaElection2019', \n",
    "                    '#Mandate2019', '#Mission2019', '#MyIndiaMyVote', \n",
    "                    '#PollOfPolls', '#PollofPolls', \n",
    "                    '#ResultDay', '#Verdict2019',\n",
    "                    '#Vote4India', '#VoteBecauseYouCan', '#VoteForChange', '#VoteForIndia', '#VoteForNewIndia', '#VoteIndia', '#VoteforIndia', '#VoteWiselyIndia']\n",
    "\n",
    "# Candidate specific hashtagsused \n",
    "candidateKeywords = ['#AaplaRahulGandhi','#AmchoRahulGandhi','#ArunachalWelcomesRahulGandhi',\n",
    "                     '#BiharRejectsModi','#BiharWithModi',\n",
    "                     '#ChowkidarNarendraModi',\n",
    "                     '#EkBarFirModiSarkar',\n",
    "                     '#FIRagainstCorruptModi',\t\n",
    "                     '#GoBackAntiNationalModi','#GoBackRahul','#GoBackModi','#GoBackPappu','#GoBackSadistModi','#GoodByeModi','#GujaratSaysNaMoAgain',\n",
    "                     '#MODIfiedJobs','#MPWithNaMo','#MaharashtraMODIfied','#MissionModi2019',\n",
    "                     '#Modi','#Modi2019Wave','#ModiAgain2019','#ModiChantSpooksCong','#ModiCorruptionYaadRakhna',\n",
    "                     '#ModiInAmethi','#ModiInGujarat','#ModiOnceMore',\n",
    "                     '#ModiTransformsBharat','#ModiVsPakistan','#ModiVsPappu','#ModiVsWho','#ModiWhereIsOurMoney','#MyFirstVoteForModi',\n",
    "                     '#NammaRahulGandhi','#NaMoAgain','#NaMoAgainAngersCong',\n",
    "                     '#PhirEkBaarModiSarkar',\n",
    "                     '#RaGaFromKarnataka','#RahulDemocracyDialogue','#RahulFromTamilNadu','#RahulGandhi','#RahulGandhiLieChallenge',\n",
    "                     '#RahulGandhiWithFishermen','#RahulLovesTerrorist',\n",
    "                     '#RahulPoliticisesPulwama','#RahulTakingIndiaForward',\n",
    "                     '#TNNaMoWarriors','#TNWelcomesModi','#TeamModi','#TripuraWelcomesRahulGandhi',\n",
    "                     '#VanakkamRahulGandhi','#VaravayiRahulGandhiYugam',\n",
    "                     '#WelcomeRahulGandhi','#WhyModiAgain']\n",
    "\n",
    "# Party specific hashtags used \n",
    "partyKeywords = ['#AntiNationalCongress', '#BJP2019Manifesto', '#BJP4BIHAR', '#BJPBetrayedDelhi', '#BJPCandidateList', '#BJPFirstList', '#BJPGameOfThieves', '#BJPInsultsMartyr', \n",
    "                 '#BJPJootaFight', '#BJPJumlaManifesto', '#BJPKiList2019', '#BJPLoanJumla', '#BJPLovesTerrorists', '#BJPMLA', '#BJPMP', '#BJPManifesto', '#BJPPollManifesto', '#BJPFoundationDay', \n",
    "                 '#BJPSankalpPatr2019', '#BJPSankalpPatra', '#BJPSthapnaDiwas', '#BJPTerrorism', '#BJPVIjaySankalpBikeRally', '#BJPVijaySankalp', '#BJPVijaySankalpBikeRally', '#BJPWebsiteHacked', \n",
    "                 '#BJPWinning', '#BJPwithKasab', '#BJPlist', '#BJPvsBJP', '#BiharNDA', '#BjpKiList2019', '#BjpWebsitehacked', '#BjpWithKasab', '#CONgressEkBailKatha', '#Cong15LakhStunt', '#CongAbsolvesPak', \n",
    "                 '#CongAdmitsJhoot', '#CongAgainstSedition', '#CongAntiForcesCampaign', '#CongArmsDealerWeb', '#CongBasicIncomeVow', '#CongBharatMataClaim', '#CongCashRaids', '#CongCasteCard', \n",
    "                 '#CongFakeCampaign', '#CongForPakistan', '#CongHawalaCashNote', '#CongInsultsMartyrs', '#CongKaCashForVote', '#CongManifesto', '#CongMasoodJhoot', '#CongMuslimVote', '#CongPollPledge', \n",
    "                 '#CongRamBhaktLie', '#CongSuperEmergency', '#CongTerrorSamjhauta', '#CongViolenceAlliance', '#CongVsForces', '#CongVsNationalInterest', '#CongizOnBackfoot', '#Congress', \n",
    "                 '#CongressAgainstDalits', '#CongressChorHai', '#CongressCollapse', '#CongressFakesItOnFB', '#CongressHaiNa', '#CongressHatesMiddleClass', '#CongressHelpingBJP', '#CongressInVidarbha', \n",
    "                 '#CongressInsultsIndia', '#CongressKaKalank', '#CongressKiFakeDiaries', '#CongressKiTerrorPolitics', '#CongressMainfesto', '#CongressManifesto', '#CongressMission25', '#CongressMuktBharat', \n",
    "                 '#CongressNaalPunjabKhushhaal', '#CongressWithPakistan', '#CongressWillDeliver', '#CongressWorkingCommittee', '#DelhiMaangeCongress', '#EtharaCongress', '#FakeItLikeCongress', \n",
    "                 '#FirstPhaseBJPFails', '#GoBackFascistBJP', '#INCForWomen', '#MahilaVirodhiBJP',  '#MasoodJiKeSaathCong', '#MyVoteForCongress', '#SayNoToBJP', '#ShameOnCongress',  '#SilentWomenOfBJP', \n",
    "                 '#TelanganaProgressWithCongress', '#UPAPoliticalSting', '#VampireCongress', '#Vote4BJP', '#Vote4Bjp', '#VoteForBJP',  '#VultureCongress', '#WomenBewareofBJP', '#BJP4India', '#BJPForIndia', \n",
    "                 '#BJPScaredOfKejriwal', '#BJPSupportsTerrorists', '#BJPWinningAmethi', '#BJPgoonBidhuri', '#BJPseDemocracyBachao', '#BengalWithBJP', '#Cong1984Shocker', '#Cong287CrCashFile', \n",
    "                 '#Cong6StrikeFactCheck', '#CongAbusesRashtrapati', '#CongAttacksSavarkar', '#CongBachaoRahulHatao', '#CongForImran', '#CongInsultsAamAadmi', '#CongInsultsPoor', '#CongKaSelfGoalHua', \n",
    "                 '#CongMediaBoycott', '#CongNeechAttackPart2', '#CongPraisesJinnah', '#CongSaffronSOS', '#CongShatruKeSaath', '#CongVsVadras', '#Conginsultspoor', '#CongressNeverAgain', '#CongressParty', \n",
    "                 '#DilliKeDilMeinCongress', '#HogiCongressKiJeet', '#IYCwithRahul', '#IndiaWithCongress', '#MeraVoteCongressKo', '#MeriAwazMeriCongress', '#NDAParliamentaryMeeting', '#TNRejectsBJP', \n",
    "                 '#VoteCutterCong', '#VoteKatwaCongress', '#congAttacksSavarkar']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run for each set of keywords and get tweets\n",
    "### Save the tweets in a file for each keyword category"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Declare start and end dates\n",
    "start_date = dt.date(2019, 1, 1) # first day of the year\n",
    "end_date = dt.date(2019, 5, 23) # day of election results\n",
    "\n",
    "#Create dataframe for generic election keywords\n",
    "electionTweets2019 = getTweets(keywords = electionKeywords,\n",
    "                               startDate = start_date,\n",
    "                               endDate = end_date,\n",
    "                               lang = 'en')\n",
    "electionTweets2019.to_csv(\"electionTweets2019.csv\")\n",
    "\n",
    "#Create dataframe for generic election keywords\n",
    "candidateTweets2019 = getTweets(keywords = candidateKeywords,\n",
    "                               startDate = start_date,\n",
    "                               endDate = end_date,\n",
    "                               lang = 'en')\n",
    "candidateTweets2019.to_csv(\"candidateTweets2019.csv\")\n",
    "\n",
    "#Create dataframe for generic election keywords\n",
    "partyTweets2019 = getTweets(keywords = partyKeywords,\n",
    "                               startDate = start_date,\n",
    "                               endDate = end_date,\n",
    "                               lang = 'en')\n",
    "partyTweets2019.to_csv(\"partyTweets2019.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load files and merge to get final dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(161324, 22)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Read three files with all the tweets\n",
    "\n",
    "electionTweets2019 = pd.read_csv(\"./Data/electionTweets2019.csv\")\n",
    "candidateTweets2019 = pd.read_csv(\"./Data/candidateTweets2019.csv\")\n",
    "partyTweets2019 = pd.read_csv(\"./Data/partyTweets2019.csv\")\n",
    "\n",
    "# merge the three dataframes\n",
    "tweets2019 =  pd.concat([electionTweets2019, candidateTweets2019, partyTweets2019], ignore_index=True)\n",
    "#size of dataset\n",
    "tweets2019.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pre-processing of tweets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(85193, 7)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get actual tweets and not replies \n",
    "tweets2019 = tweets2019[tweets2019['is_reply_to' ] == False]\n",
    "\n",
    "# dropping duplicate values \n",
    "tweets2019 = tweets2019.drop_duplicates(subset = 'tweet_id')\n",
    "\n",
    "# drop tweets from media agencies, news channels, newspapers\n",
    "tweets2019 = tweets2019[tweets2019['username']\n",
    "                        .str.contains(\"news|tv|times|media|toi|council|statesman|mandate|press|now|firstpost|Live|deccan|express|outlook|the \", case= False) == False]\n",
    "\n",
    "# extract selected columns \n",
    "tweets2019 = tweets2019.filter(['tweet_id','timestamp','text', 'user_id','username', 'screen_name'], axis=1).sort_values(by=['tweet_id']).reset_index()\n",
    "\n",
    "#rename columns\n",
    "tweets2019.rename(columns={'tweet_id':'TweetID',\n",
    "                           'timestamp':'TimeStamp',\n",
    "                           'text' : 'Tweet', \n",
    "                           'user_id' : 'UserID',\n",
    "                           'username' : 'UserName', \n",
    "                           'screen_name' : 'ScreenName'},\n",
    "                  inplace=True)\n",
    "\n",
    "# drop index column\n",
    "tweets2019 = tweets2019.drop(['index'],axis = 1)\n",
    "\n",
    "# add new column categorise tweets by parties\n",
    "tweets2019['Party'] = tweets2019['Tweet'].apply(categorize)\n",
    "\n",
    "# drop all entries with no party category\n",
    "tweets2019 = tweets2019[tweets2019['Party']!='None']\n",
    "\n",
    "# add capitalized words again to text\n",
    "tweets2019['Tweet'] = tweets2019['Tweet'].apply(repeatCapitalWords)\n",
    "\n",
    "# Remove all hyperlinks, whitespaces and twitterhandles\n",
    "tweets2019 = tweets2019.assign(Tweet = lambda x: x[\"Tweet\"].str.replace(r\"http\\S+|#\\S+|@\\S+\", \"\", regex=True)) \n",
    "tweets2019 = tweets2019.assign(Tweet = lambda x: x[\"Tweet\"].str.replace(r\"pic.twitter\\S+\", \"\", regex=True)) \n",
    "\n",
    "# apply pre-process steps\n",
    "tweets2019['Tweet'] = tweets2019['Tweet'].apply(pre_process)\n",
    "\n",
    "# Save dataset to file\n",
    "tweets2019.to_csv(\"./Data/Tweets2019.csv\")\n",
    "\n",
    "# size of dataset after pre-processing\n",
    "tweets2019.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load final dataset from file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Party</th>\n",
       "      <th>Count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>BJP</td>\n",
       "      <td>32731</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Both</td>\n",
       "      <td>20832</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Congress</td>\n",
       "      <td>31630</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Party  Count\n",
       "0       BJP  32731\n",
       "1      Both  20832\n",
       "2  Congress  31630"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#tweets2019 = pd.read_csv(\"./Data/Tweets2019.csv\")\n",
    "\n",
    "# tweet count for each party category\n",
    "tweets2019.groupby(['Party']).size().reset_index(name='Count')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1: Checking for Bot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load package\n",
    "import botometer\n",
    "\n",
    "# set rapid api key\n",
    "rapidapi_key = \"761c3f590emsha5c171f2911c27bp1f4826jsnbbac887cd7d5\" # now it's called rapidapi key\n",
    "\n",
    "# set twitter developer credentials\n",
    "twitter_app_auth = {\n",
    "    'consumer_key': 'bfSuAdueneFZpRvA9Pwrx3VtG',\n",
    "    'consumer_secret': '8sL2mXYkPyz8YjqP0WO7bHPaHsjMc7EuPQT41ekRjbSxhdVwze',\n",
    "    'access_token': '855084907365715968-a9rslInMObUk0R91CWVStf7SPiIRble',\n",
    "    'access_token_secret': 'HpPuzBC516Hri88qHtc2NU973iVDO4nofqtuooPTtZtnT',\n",
    "  }\n",
    "\n",
    "# create instance of botometer class to get bot score\n",
    "bom = botometer.Botometer(wait_on_ratelimit=True,\n",
    "                          rapidapi_key=rapidapi_key,\n",
    "                          **twitter_app_auth)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get all unique user ids from Twitter Election dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Party</th>\n",
       "      <th>Count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>BJP</td>\n",
       "      <td>14846</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Congress</td>\n",
       "      <td>12509</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Both</td>\n",
       "      <td>7756</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      Party  Count\n",
       "0       BJP  14846\n",
       "2  Congress  12509\n",
       "1      Both   7756"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "userIdDF = tweets2019[['UserID', 'ScreenName','Party']].drop_duplicates(subset = 'UserID')\n",
    "userIdDF.groupby(['Party']).size().reset_index(name='Count').sort_values(by='Count',ascending=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get bot score for each unique user, based on the party category\n",
    "### Save the details in a file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get Unique ids for BJP and get Bot score for each\n",
    "userId_BJP = userIdDF[userIdDF['Party']=='BJP']\n",
    "userId_BJP['BotScore'] = userId_BJP['UserID'].apply(getBotScore)\n",
    "userId_BJP.to_csv(\"./Data/userId_BJP.csv\")\n",
    "\n",
    "# Get Unique ids for Congress and get Bot score for each\n",
    "userId_Congress = userIdDF[userIdDF['Party']=='Congress']\n",
    "userId_Congress['BotScore'] = userId_Congress['UserID'].apply(getBotScore)\n",
    "userId_Congress.to_csv(\"./Data/userId_Congress.csv\")\n",
    "\n",
    "# Get Unique ids that tweeted for both BJP and Cpngress and get Bot score for each\n",
    "userId_Both = userIdDF[userIdDF['Party']=='Both']\n",
    "userId_Both['BotScore'] = userId_Both['UserID'].apply(getBotScore)\n",
    "userId_Both.to_csv(\"./Data/userId_Both.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Once all the scores were retreived, we merge the datasets together to get a combined dataset for all the unique user ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Since we already have data saved in the files, we load the files rather running the script each time \n",
    "userId_BJP = pd.read_csv(\"./Data/userId_BJP.csv\")\n",
    "userId_Congress = pd.read_csv(\"./Data/userId_Congress.csv\")\n",
    "userId_Both = pd.read_csv(\"./Data/userId_Both.csv\")\n",
    "\n",
    "# Merge all three datasets\n",
    "userIDScoreCombined =  pd.concat([userId_BJP, userId_Congress, userId_Both], ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(35111, 5)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Code to make sure we only extract all the unique user ids present in Twitter Election dataset\n",
    "userIDScoreCombined = pd.merge(userIdDF,userIDScoreCombined,on=['UserID', 'ScreenName', 'Party'],how='left')\n",
    "userIDScoreCombined = userIDScoreCombined = userIDScoreCombined[['UserID','ScreenName','Party','BotScore']]\n",
    "\n",
    "# Assign account type based on the Bot score for each user\n",
    "userIDScoreCombined['Status'] = userIDScoreCombined['BotScore'].apply(checkBotStatus)\n",
    "\n",
    "# Size of dataset: no of unique users\n",
    "userIDScoreCombined.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Status</th>\n",
       "      <th>Count</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Human</td>\n",
       "      <td>28973</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Human-like Bot</td>\n",
       "      <td>4334</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Simple Bot</td>\n",
       "      <td>1141</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Suspended</td>\n",
       "      <td>663</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           Status  Count\n",
       "0           Human  28973\n",
       "1  Human-like Bot   4334\n",
       "2      Simple Bot   1141\n",
       "3       Suspended    663"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# See count for each account type\n",
    "userIDCount = userIDScoreCombined.groupby(['Status']).size().reset_index(name='Count')\n",
    "userIDCount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a pie chart\n",
    "plt.pie(\n",
    "    # using tweets\n",
    "    userIDCount['Count'],\n",
    "    # with no shadows\n",
    "    shadow=False,\n",
    "    # with the start angle at 30%\n",
    "    startangle=30,\n",
    "    # with the percent listed as a fraction\n",
    "    autopct='%1.0f%%'\n",
    "    )\n",
    "\n",
    "# View the plot drop above\n",
    "plt.axis('equal')\n",
    "plt.legend(userIDCount['Status'], loc=\"best\")\n",
    "# View the plot\n",
    "plt.tight_layout()\n",
    "plt.savefig('./Plots/pie.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>Status</th>\n",
       "      <th>Human</th>\n",
       "      <th>Human-like Bot</th>\n",
       "      <th>Simple Bot</th>\n",
       "      <th>Suspended</th>\n",
       "      <th>Total</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Party</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BJP</th>\n",
       "      <td>12245</td>\n",
       "      <td>1915</td>\n",
       "      <td>589</td>\n",
       "      <td>97</td>\n",
       "      <td>14846</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Congress</th>\n",
       "      <td>10180</td>\n",
       "      <td>1531</td>\n",
       "      <td>301</td>\n",
       "      <td>497</td>\n",
       "      <td>12509</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Both</th>\n",
       "      <td>6548</td>\n",
       "      <td>888</td>\n",
       "      <td>251</td>\n",
       "      <td>69</td>\n",
       "      <td>7756</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Status    Human  Human-like Bot  Simple Bot  Suspended  Total\n",
       "Party                                                        \n",
       "BJP       12245            1915         589         97  14846\n",
       "Congress  10180            1531         301        497  12509\n",
       "Both       6548             888         251         69   7756"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check distribution of each account type for all party categories\n",
    "botCountDF = userIDScoreCombined.groupby(['Status','Party']).size().reset_index(name='Count').pivot(index='Party',columns='Status',values='Count')\n",
    "botCountDF['Total'] = botCountDF.sum(axis=1)\n",
    "botCountDF = botCountDF.sort_values(by='Total',ascending=False)\n",
    "botCountDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot for distribution of each account type for all party categories\n",
    "df_total = botCountDF['Total']\n",
    "df = botCountDF.iloc[:, 0:4]\n",
    "df.plot(kind='barh',stacked = True,title = 'User% for each account type', mark_right = False,  figsize=(10,7))\n",
    "\n",
    "df_rel = df[df.columns[:]].div(df_total, 0)*100\n",
    "\n",
    "for n in df_rel:\n",
    "    for i, (cs, ab, pc, tot) in enumerate(zip(df.iloc[:, 0:].cumsum(1)[n], df[n], df_rel[n], df_total)):\n",
    "        #plt.text(tot, i, str(tot), va='center')\n",
    "        plt.text(cs - ab/2, i, str(int(np.round(pc, 0))) , va='center', ha='center')\n",
    "\n",
    "plt.savefig('./Plots/botCount.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assign account type based on user id for each user in Twitter Election dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "tweets2019 = pd.merge(tweets2019,userIDScoreCombined[['UserID','Status']], on='UserID',how='left')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>Status</th>\n",
       "      <th>Human</th>\n",
       "      <th>Human-like Bot</th>\n",
       "      <th>Simple Bot</th>\n",
       "      <th>Suspended</th>\n",
       "      <th>Total</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Party</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BJP</th>\n",
       "      <td>27801</td>\n",
       "      <td>3675</td>\n",
       "      <td>867</td>\n",
       "      <td>388</td>\n",
       "      <td>32731</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Congress</th>\n",
       "      <td>26566</td>\n",
       "      <td>3563</td>\n",
       "      <td>515</td>\n",
       "      <td>986</td>\n",
       "      <td>31630</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Both</th>\n",
       "      <td>17466</td>\n",
       "      <td>2270</td>\n",
       "      <td>757</td>\n",
       "      <td>339</td>\n",
       "      <td>20832</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Status    Human  Human-like Bot  Simple Bot  Suspended  Total\n",
       "Party                                                        \n",
       "BJP       27801            3675         867        388  32731\n",
       "Congress  26566            3563         515        986  31630\n",
       "Both      17466            2270         757        339  20832"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check distribution of tweets for all party categories based on account type\n",
    "tweetBotCountDF = tweets2019.groupby(['Status','Party']).size().reset_index(name='Count').pivot(index='Party',columns='Status',values='Count')\n",
    "tweetBotCountDF['Total'] = tweetBotCountDF.sum(axis=1)\n",
    "tweetBotCountDF = tweetBotCountDF.sort_values(by='Total',ascending=False)\n",
    "tweetBotCountDF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot distribution of tweets for all party categories based on account type\n",
    "df_total = tweetBotCountDF['Total']\n",
    "df = tweetBotCountDF.iloc[:, 0:4]\n",
    "df.plot(kind='barh',stacked = True, title = 'Tweet% for each account type', mark_right = False,  figsize=(15,7))\n",
    "\n",
    "df_rel = df[df.columns[:]].div(df_total, 0)*100\n",
    "\n",
    "for n in df_rel:\n",
    "    for i, (cs, ab, pc, tot) in enumerate(zip(df.iloc[:, 0:].cumsum(1)[n], df[n], df_rel[n], df_total)):\n",
    "        plt.text(cs - ab/2, i, str(int(np.round(pc, 0))) , va='center', ha='center', size = 8)\n",
    "\n",
    "plt.savefig('./Plots/tweetBotCount.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2: Sentiment Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Data: Sentiment140"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(200000, 6)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Column names for relevant columns\n",
    "colNames = ['Sentiment', 'TweetID', 'Date', 'Query', 'Username','Text']\n",
    "# Load Sentiment140 dataset from file\n",
    "trainingDataSet = pd.read_csv(\"./Data/Sentiment140.csv\", names = colNames, encoding= 'ISO-8859-1',header=None)\n",
    "\n",
    "# Take sample of Sentiment140 dataset for training data\n",
    "trainingDataSet = trainingDataSet.sample(frac = 0.125, random_state = 100)\n",
    "\n",
    "#Change all positive sentiment values from 4 to 1\n",
    "trainingDataSet.loc[trainingDataSet['Sentiment'] == 4, 'Sentiment'] = 1\n",
    "\n",
    "#  check for capitalized words and add to text\n",
    "trainingDataSet['Text'] = trainingDataSet['Text'].apply(repeatCapitalWords)\n",
    "\n",
    "# Remove all hyperlinks, whitespaces and twitterhandles, if any\n",
    "trainingDataSet = trainingDataSet.assign(Text = lambda x: x[\"Text\"].str.replace(r\"http\\S+|#\\S+|@\\S+\", \"\", regex=True)) \n",
    "trainingDataSet = trainingDataSet.assign(Text = lambda x: x[\"Text\"].str.replace(r\"pic.twitter\\S+\", \"\", regex=True)) \n",
    "\n",
    "# size of dataset\n",
    "trainingDataSet.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>TweetID</th>\n",
       "      <th>Date</th>\n",
       "      <th>Query</th>\n",
       "      <th>Username</th>\n",
       "      <th>Text</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sentiment</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100202</td>\n",
       "      <td>100202</td>\n",
       "      <td>100202</td>\n",
       "      <td>100202</td>\n",
       "      <td>100202</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>99798</td>\n",
       "      <td>99798</td>\n",
       "      <td>99798</td>\n",
       "      <td>99798</td>\n",
       "      <td>99798</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           TweetID    Date   Query  Username    Text\n",
       "Sentiment                                           \n",
       "0           100202  100202  100202    100202  100202\n",
       "1            99798   99798   99798     99798   99798"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check if equal distribution of positive and negative tweets\n",
    "trainingDataSet.groupby(['Sentiment']).count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Glove Word Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read word embeddings\n",
    "#glove_file = open('./glove.6B.100d.txt', encoding=\"utf8\")\n",
    "glove_file = open('./Data/glove.twitter.27B.100d.txt', encoding=\"utf8\")\n",
    "dictionary = {}\n",
    "\n",
    "for line in glove_file:\n",
    "    values = line.split()\n",
    "    word = values[0]\n",
    "    try:\n",
    "        vector = np.asarray(values[1:], dtype='float32')\n",
    "    except:\n",
    "        print(values[1:])\n",
    "    \n",
    "    dictionary[word] = vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train-Test Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           TweetID   Date  Query  Username   Text\n",
      "Sentiment                                        \n",
      "0            80277  80277  80277     80277  80277\n",
      "1            79723  79723  79723     79723  79723            TweetID   Date  Query  Username   Text\n",
      "Sentiment                                        \n",
      "0            19925  19925  19925     19925  19925\n",
      "1            20075  20075  20075     20075  20075\n"
     ]
    }
   ],
   "source": [
    "# split Sentiment140 dataset into training and test set for the model\n",
    "trainData, testData = train_test_split(trainingDataSet, test_size=0.2, random_state=100)\n",
    "print(trainData.groupby(['Sentiment']).count(), testData.groupby(['Sentiment']).count())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pre-processing for model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create X and Y numpy arrays; preprocessing required for keral model \n",
    "# X: Text of the tweet; Y: Sentiment of the tweet (0,1)\n",
    "\n",
    "# Create X and Y numpy arrays for training set\n",
    "train_text_array = trainData[\"Text\"].to_numpy()\n",
    "X_train = [pre_process(text) for text in train_text_array]\n",
    "y_train = trainData[\"Sentiment\"].to_numpy()\n",
    "\n",
    "# Create X and Y numpy arrays for test set\n",
    "test_text_array = testData[\"Text\"].to_numpy()\n",
    "X_test = [pre_process(text) for text in test_text_array]\n",
    "y_test = testData[\"Sentiment\"].to_numpy()\n",
    "\n",
    "# Create numpy arrays for training set\n",
    "electionTweet_array = tweets2019[\"Tweet\"].to_numpy()\n",
    "electionTweet = [pre_process(text) for text in electionTweet_array]\n",
    "\n",
    "# Create a dictionary by converting each vocabulary word into an index value\n",
    "tknzr = Tokenizer(num_words = 5000)\n",
    "tknzr.fit_on_texts(X_train)\n",
    "\n",
    "# Transform the tweets into a set of numbers using tokenizer\n",
    "X_train = tknzr.texts_to_sequences(X_train)\n",
    "X_test = tknzr.texts_to_sequences(X_test)\n",
    "electionTweet = tknzr.texts_to_sequences(electionTweet)\n",
    "\n",
    "# +1 because Keras in keras the index 0 is reserved\n",
    "vocabulary_size = len(tknzr.word_index) + 1\n",
    "\n",
    "# Max length of the tweet. Each tweet that is longer is truncated; in this case not possible as max permissible length of tweet is 140 characters\n",
    "max_length = 140\n",
    "\n",
    "# Tweets that are shorter are padded with 0s\n",
    "X_train = pad_sequences(X_train, padding='post', maxlen=max_length)\n",
    "X_test = pad_sequences(X_test, padding='post', maxlen=max_length)\n",
    "electionTweet = pad_sequences(electionTweet, padding='post', maxlen=max_length)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Word Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create embedding matrix where each row is the index representing a word and columns represent vectorspace dimensions\n",
    "embedding_matrix = np.zeros((vocabulary_size, 100))\n",
    "for word, index in tknzr.word_index.items():\n",
    "    embedding = dictionary.get(word)\n",
    "    if embedding is not None:\n",
    "        embedding_matrix[index] = embedding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convolutional Neural Network Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_1 (Embedding)      (None, 140, 100)          6731700   \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 140, 100)          0         \n",
      "_________________________________________________________________\n",
      "conv1d_1 (Conv1D)            (None, 138, 200)          60200     \n",
      "_________________________________________________________________\n",
      "conv1d_2 (Conv1D)            (None, 137, 200)          80200     \n",
      "_________________________________________________________________\n",
      "global_max_pooling1d_1 (Glob (None, 200)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 100)               20100     \n",
      "_________________________________________________________________\n",
      "dropout_2 (Dropout)          (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "activation_1 (Activation)    (None, 100)               0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 1)                 101       \n",
      "=================================================================\n",
      "Total params: 6,892,301\n",
      "Trainable params: 160,601\n",
      "Non-trainable params: 6,731,700\n",
      "_________________________________________________________________\n",
      "None\n",
      "Train on 128000 samples, validate on 32000 samples\n",
      "Epoch 1/7\n",
      "128000/128000 [==============================] - 163s 1ms/step - loss: 0.5150 - acc: 0.7426 - val_loss: 0.4653 - val_acc: 0.7773\n",
      "Epoch 2/7\n",
      "128000/128000 [==============================] - 138s 1ms/step - loss: 0.4728 - acc: 0.7741 - val_loss: 0.4494 - val_acc: 0.7878\n",
      "Epoch 3/7\n",
      "128000/128000 [==============================] - 147s 1ms/step - loss: 0.4522 - acc: 0.7862 - val_loss: 0.4428 - val_acc: 0.7934\n",
      "Epoch 4/7\n",
      "128000/128000 [==============================] - 145s 1ms/step - loss: 0.4396 - acc: 0.7942 - val_loss: 0.4379 - val_acc: 0.7945\n",
      "Epoch 5/7\n",
      "128000/128000 [==============================] - 146s 1ms/step - loss: 0.4285 - acc: 0.8011 - val_loss: 0.4376 - val_acc: 0.7962\n",
      "Epoch 6/7\n",
      "128000/128000 [==============================] - 145s 1ms/step - loss: 0.4191 - acc: 0.8046 - val_loss: 0.4376 - val_acc: 0.7956\n",
      "Epoch 7/7\n",
      "128000/128000 [==============================] - 147s 1ms/step - loss: 0.4092 - acc: 0.8110 - val_loss: 0.4434 - val_acc: 0.7969\n",
      "40000/40000 [==============================] - 12s 291us/step\n",
      "Score: 45.0 %\n",
      "Accuracy: 80.0 %\n"
     ]
    }
   ],
   "source": [
    "# set seed \n",
    "from numpy.random import seed\n",
    "seed(10)\n",
    "\n",
    "# Callback function to stop the training early if the accuracy on the validation score drops for 2 consecutive epochs.\n",
    "es =  EarlyStopping(monitor='val_loss',\n",
    "                   min_delta=0,\n",
    "                   patience=2,\n",
    "                   verbose=1, mode='auto')\n",
    "\n",
    "# Create a sequential model\n",
    "model = Sequential()\n",
    "\n",
    "# embedding layer\n",
    "embedding_layer = Embedding(vocabulary_size, 100, weights=[embedding_matrix], input_length=max_length , trainable=False)\n",
    "model.add(embedding_layer)\n",
    "\n",
    "# dropout layer with 20% probability\n",
    "model.add(Dropout(0.2))\n",
    "\n",
    "# convolutional layers\n",
    "model.add(Conv1D(200, 3, padding = \"valid\", activation='relu')) #kernel size 3, for trigrams\n",
    "model.add(Conv1D(200, 2, padding = \"valid\", activation='relu')) #kernel size 2, for bigrams\n",
    "\n",
    "# max pooling layer\n",
    "model.add(GlobalMaxPooling1D())\n",
    "\n",
    "# fully connected layer\n",
    "model.add(Dense(100))\n",
    "# dropout layer with 20% probability\n",
    "model.add(Dropout(0.2))\n",
    "\n",
    "#output layer\n",
    "model.add(Activation('relu'))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])\n",
    "\n",
    "# display model summary\n",
    "print(model.summary())\n",
    "\n",
    "# model training \n",
    "history = model.fit(X_train, y_train, batch_size=64, epochs=7, verbose=1, validation_split=0.2, callbacks=[es])\n",
    "\n",
    "# get model metrics\n",
    "score = model.evaluate(X_test, y_test, verbose=1)\n",
    "\n",
    "# display model metrics\n",
    "print(\"Score:\", round(score[0],2)*100,\"%\")\n",
    "print(\"Accuracy:\", round(score[1],2)*100,\"%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Code gotten from https://machinelearningmastery.com/display-deep-learning-model-training-history-in-keras/\n",
    "\n",
    "plt.plot(history.history['acc'])\n",
    "plt.plot(history.history['val_acc'])\n",
    "\n",
    "plt.title('Model accuracy')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Training set','Testing set'], loc='upper left')\n",
    "plt.savefig(\"./Plots/accuracy.png\")\n",
    "plt.show()\n",
    "\n",
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n",
    "\n",
    "plt.title('Model loss')\n",
    "plt.ylabel('Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(['Training set','Testing set'], loc='upper left')\n",
    "plt.savefig(\"./Plots/loss.png\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predict sentiment for Twitter Election dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get predicted sentiment labels (0,1) \n",
    "# add values to new columns in dataset \n",
    "sentiment_pred = model.predict_classes(electionTweet)\n",
    "sentiment_pred = np.reshape(sentiment_pred,(sentiment_pred.shape[0],))\n",
    "tweets2019[\"Predicted Sentiment\"] =  sentiment_pred\n",
    "\n",
    "# Set sentiment as 'Positive' if label is 1, else set as 'Negative'\n",
    "tweets2019[\"Predicted Sentiment\"] = tweets2019[\"Predicted Sentiment\"].apply(lambda x: 'Positive' if x==1 else 'Negative')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Predicted Sentiment</th>\n",
       "      <th>Count</th>\n",
       "      <th>Percentage</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Negative</td>\n",
       "      <td>38093</td>\n",
       "      <td>44.71</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Positive</td>\n",
       "      <td>47100</td>\n",
       "      <td>55.29</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Predicted Sentiment  Count  Percentage\n",
       "0            Negative  38093       44.71\n",
       "1            Positive  47100       55.29"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check distribution/percentage of predicted sentiment \n",
    "tweetSentiment = tweets2019.groupby(['Predicted Sentiment']).size().reset_index(name='Count')\n",
    "tweetSentiment['Percentage'] = round((tweetSentiment['Count'] / tweetSentiment['Count'].sum()) * 100,2)\n",
    "tweetSentiment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis of Predicted Sentiment for tweets by all accounts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>Predicted Sentiment</th>\n",
       "      <th>Negative</th>\n",
       "      <th>Positive</th>\n",
       "      <th>Total</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Party</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BJP</th>\n",
       "      <td>14139</td>\n",
       "      <td>18592</td>\n",
       "      <td>32731</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Both</th>\n",
       "      <td>10253</td>\n",
       "      <td>10579</td>\n",
       "      <td>20832</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Congress</th>\n",
       "      <td>13701</td>\n",
       "      <td>17929</td>\n",
       "      <td>31630</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Predicted Sentiment  Negative  Positive  Total\n",
       "Party                                         \n",
       "BJP                     14139     18592  32731\n",
       "Both                    10253     10579  20832\n",
       "Congress                13701     17929  31630"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check distribution/percentage of predicted sentiment for each account category\n",
    "dfAll = tweets2019.groupby(['Predicted Sentiment','Party']).size().reset_index(name='Count').pivot(index='Party',columns='Predicted Sentiment',values='Count')\n",
    "dfAll['Total'] = dfAll.sum(axis=1)\n",
    "\n",
    "dfAll_total = dfAll['Total']\n",
    "dfAllPercentage = round(dfAll[dfAll.columns[:-1]].div(dfAll_total, 0)*100,2)\n",
    "\n",
    "dfAll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axAllPercentage = dfAllPercentage.plot(kind='bar',stacked = False, figsize=(10,7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmMAAAG5CAYAAADChTOpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdeXgV5d3/8feXTUQEQcCCUaDKHpIYggIqopRNrYpWBewDgvxQa7VuVNS61gWXVkQtbqDoY0ErotQHMKggVBEIGiyiCApCFGWRfQ98f3/M5HACAbJPAp/XdZ0rZ+7Z7jmZM+dz7rlnjrk7IiIiIhKNClFXQERERORwpjAmIiIiEiGFMREREZEIKYyJiIiIREhhTERERCRCCmMiIiIiEVIYE5ESY2bPmtldUdcjL2bWzMw+N7ONZnZDKazPzezk8PnLZvZASa9TRMoHhTGRw4yZnWFmn5jZejP7xcw+NrO2xbDcK83sP/Fl7n6Nu/+1qMsuRF3uNbP/PchkfwamufvR7j68NOqVH3m9jqW03lhYFJHSpTAmchgxsxrAu8BTQG3geOA+YHuU9YpIQ+DLwsxoZpWKuS4ichhTGBM5vDQFcPcx7r7L3be6e7q7f5EzgZkNMLOvzGytmb1nZg3jxrmZXWNmi8Lxz1igBfAs0N7MNpnZunD62Ok4M+tkZllm9mczW2lmK8zsIjM718y+CVvp7ohbVwUzG2Jm35rZGjN7w8xqh+MahXXpZ2bLzGy1md0ZjusO3AFcHtZl3t4vgpl9CJwNPB1O09TMaprZK2a2ysy+N7O/mFmFcPorwxbEJ8zsF+DePJZ5qpnNNLN14bY9bWZVCvLPyet1NLPG4d+curxoZivj5vlfM7sxfF7TzEaG6//BzB4ws4oH+9+a2fRwknnhei83szpm9m647l/MbEZOHUSkeOmNJXJ4+QbYZWajzayHmdWKH2lmFxEEmYuBusAMYMxeyzgfaAskA5cB3dz9K+AaYKa7V3f3Y/az/l8BVQla5O4GXgB+D7QBzgTuNrNfh9PeAFwEnAU0ANYCz+y1vDOAZkDncN4W7j4ZeAh4PaxL8t6VcPdzwm37YzjNNwSthTWBX4fr7Av0j5vtNOA7oB7wYB7btgu4CagDtA/r9If9vA55yut1dPclwAbglHCyM4FNYXAD6Ah8FD4fDWQDJ4fTdwUGwoH/t+7eMZw/OVzv68AtQFY47XHhvPr9PJESoDAmchhx9w0EAcYJgtAqM5tgZseFk1wNPOzuX7l7NkGoSYlvHQOGuvs6d18GTAVSClCFncCD7r4TGEsQXJ50943u/iXBacOkuLrc6e5Z7r6doDXqd3udIrwvbN2bB8wjCIgFFrYeXQ7cHtZlKfA34H/iJvvR3Z9y92x337r3Mtx9rrt/Go5fCjxHEOqKw0fAWWb2q3D4zXC4MVCDoEXrOKAHcKO7b3b3lcATQK9wnvz8b+PtBOoDDd19p7vPcP2YsUiJUBgTOcyEH8ZXunsCkEjQ6jQsHN0QeDI8NbUO+AUwgpasHD/FPd8CVC/A6te4+67weU6g+Tlu/Na45TUExsfV5SuC1qfj4qYvSl3i1QGqAN/HlX1P7u1efqAFhKc63zWzn8xsA0HYqVPI+uztI6ATQSvYdGAaQdA7C5jh7rsJXq/KwIq41+w5gpY8yN//Nt5jwGIg3cy+M7MhxbQtIrIXhTGRw5i7fw28TBDKIAgcV4enx3IeR7r7J/lZXDFXbznQY6+6VHX3H0qgLqsJWoLiW4lOBOLXdbBljgC+Bpq4ew2C03pWwHrsbz0fEZye7BQ+/w9wOkEYyzlFuZzgQow6ca9XDXdvFTc+3//bsIXwFnf/NfBb4GYz61yI7RGRg1AYEzmMmFlzM7vFzBLC4ROA3sCn4STPArebWatwfE0zuzSfi/8ZSChop/UDeBZ4MK6TeV0zu7AAdWmU3w7nYWvdG+H6jg7XeTNwsNtjxDuaoG/XJjNrDlxbgHnj7fM6uvsiglbD3wPTw9PNPwOXEIYxd18BpAN/M7Ma4QUQJ5lZzqnSg/1vfyboL0c4/nwzO9nMLNyuXeFDRIqZwpjI4WUjQUf0WWa2mSCEzSforI27jwceAcaGp9rmE/RDyo8PCfp8/WRmq4uhrk8CEwhOk20M63paPuf9V/h3jZl9ls95rgc2E3TS/w/wT2BU/qvLrUAfgtf4BeD1Aswbb3+v40cEp3mXxQ0b8HncNH0JTrcuILjg4U2Cfl/5+d/eC4wOT2NeBjQB3gc2ATOBf7j7tEJuk4gcgKk/poiIiEh01DImIiIiEiGFMREREZEIKYyJiIiIREhhTERERCRC5fbHbuvUqeONGjWKuhoiIiIiBzV37tzV7l43r3HlNow1atSIjIyMqKshIiIiclBm9v3+xuk0pYiIiEiEFMZEREREIqQwJsVmwIAB1KtXj8TExFhZZmYm7dq1IyUlhbS0NGbPng3AtGnTqFmzJikpKaSkpHD//ffH5nnyySdJTEykVatWDBs2LFY+ePBgmjdvTlJSEj179mTdunWlt3EiIiIlpNzegT8tLc3VZ6xsmT59OtWrV6dv377Mnz8fgK5du3LTTTfRo0cPJk6cyKOPPsq0adOYNm0ajz/+OO+++26uZcyfP59evXoxe/ZsqlSpQvfu3RkxYgRNmjQhPT2dc845h0qVKnHbbbcB8Mgjj5T6dgrs3LmTrKwstm3bFnVVJJ+qVq1KQkIClStXjroqIoclM5vr7ml5jSu3Hfil7OnYsSNLly7NVWZmbNiwAYD169fToEGDAy7jq6++ol27dlSrVg2As846i/Hjx/PnP/+Zrl27xqZr164db775ZvFugORbVlYWRx99NI0aNSL4HWkpy9ydNWvWkJWVRePGjaOujojsRacppUQNGzaMwYMHc8IJJ3Drrbfy8MMPx8bNnDmT5ORkevTowZdffglAYmIi06dPZ82aNWzZsoWJEyeyfPnyfZY7atQoevTI7+9XS3Hbtm0bxx57rIJYOWFmHHvssWrJFCmjFMakRI0YMYInnniC5cuX88QTT3DVVVcBkJqayvfff8+8efO4/vrrueiiiwBo0aIFt912G126dKF79+4kJydTqVLuBtwHH3yQSpUqccUVV5T69sgeCmLli/5fImWXwpiUqNGjR3PxxRcDcOmll8Y68NeoUYPq1asDcO6557Jz505Wr14NwFVXXcVnn33G9OnTqV27Nk2aNMm1vHfffZfXXntNHy4iInJIUBiTEtWgQQM++ugjAD788MNYsPrpp5/IuXhk9uzZ7N69m2OPPRaAlStXArBs2TLeeustevfuDcDkyZN55JFHmDBhQqxPmZQdFStWJCUlhcTERC699FK2bNlS6GVNmzaN888/H4AJEyYwdOjQ/U67bt06/vGPfxR4Hffeey+PP/74PuULFy6kU6dOpKSk0KJFCwYNGlTgZecYNmxYrtfh3HPPLfGrgB966KESXb6IFD+FMSk2vXv3pn379ixcuJCEhARGjhzJCy+8wC233EJycjJ33HEHzz//PABvvvkmiYmJJCcnc8MNNzB27NhYS9cll1xCy5Yt+e1vf8szzzxDrVq1APjjH//Ixo0b6dKlCykpKVxzzTWRbavs68gjjyQzM5P58+dTpUoVnn322Vzj3Z3du3cXeLkXXHABQ4YM2e/4woax/bnhhhu46aabyMzM5KuvvuL6668v9LL2DmMTJ07kmGOOKY5q7pfCmEg55O7l8tGmTRsXkWgsWLBgn7Kjjjoq9nzEiBF+7bXX+pIlS7x58+Z+7bXXekpKii9dutTfe+89b9eunZ9yyin+u9/9zjdu3Oju7pMmTfJmzZr56aef7tdff72fd9557u7+0ksv+XXXXefu7j/99JNfdNFFnpSU5ElJSf7xxx/75Zdf7lWrVvXk5GS/9dZb3d390Ucf9bS0NG/durXffffdsXo98MAD3rRpU+/cubP36tXLH3vssX22o3Xr1p6RkbFPeXZ2tt96662x5T777LPu7j516lQ/66yz/JJLLvFmzZp5nz59fPfu3f7kk0965cqVPTEx0Tt16uTu7g0bNvRVq1b5kiVLvFmzZn7VVVd5q1atvE+fPj5lyhTv0KGDn3zyyT5r1ix3d9+0aZP379/f09LSPCUlxd9+++3Ya9KzZ0/v1q2bn3zyyT548GB3d7/tttu8QoUKnpyc7H369MnX/01ESgeQ4fvJNJGHqsI+FMZEonOgMLZz506/4IIL/B//+IcvWbLEzcxnzpzp7u6rVq3yM8880zdt2uTu7kOHDvX77rvPt27d6gkJCf7NN9/47t27/dJLL80zjF122WX+xBNPuHsQjtatW+dLlizxVq1axerx3nvv+f/7f//Pd+/e7bt27fLzzjvPP/roI8/IyPDExETfvHmzr1+/3k866aQ8w9ioUaO8Ro0a3r17d//73//ua9eudXf35557zv/617+6u/u2bdu8TZs2/t133/nUqVO9Ro0avnz5ct+1a5e3a9fOZ8yY4e57wleO+DBWsWJF/+KLL3zXrl2emprq/fv39927d/vbb7/tF154obu733777f7qq6+6u/vatWu9SZMmvmnTJn/ppZe8cePGvm7dOt+6daufeOKJvmzZslz/h/z+30SkdBwojOk+YyJSLLZu3UpKSgoAZ555JldddRU//vgjDRs2pF27dgB8+umnLFiwgNNPPx2AHTt20L59e77++msaN24c61P4+9//PnZKO96HH37IK6+8AgR91GrWrMnatWtzTZOenk56ejqnnHIKAJs2bWLRokVs3LiRnj17xvobXnDBBXluR//+/enWrRuTJ0/mnXfe4bnnnmPevHmkp6fzxRdfxO5vt379ehYtWkSVKlU49dRTSUhIACAlJYWlS5dyxhlnHPD1aty4Ma1btwagVatWdO7cGTOjdevWsfv1paenM2HChFjftm3btrFs2TIAOnfuTM2aNQFo2bIl33//PSeccMIB1ykiZZPCmIgUi5w+Y3s76qijYs/dnS5dujBmzJhc02RmZhbb1bHuzu23387VV1+dq3zYsGH5XkeDBg0YMGAAAwYMIDExkfnz5+PuPPXUU3Tr1i3XtNOmTeOII46IDVesWJHs7OyDriN+ngoVKsSGK1SoEJvf3Rk3bhzNmjXLNe+sWbMKtU4RKZvUgV9ESk27du34+OOPWbx4MQBbtmzhm2++oXnz5ixZsoRvv/0WYJ+wlqNz586MGDECgF27drFhwwaOPvpoNm7cGJumW7dujBo1ik2bNgHwww8/sHLlSjp27Mj48ePZunUrGzdu5N///nee65g8eTI7d+4Egqt+16xZw/HHH0+3bt0YMWJEbNw333zD5s2bD7i9e9etoLp168ZTTz0Vu/L4888/P+g8lStXjtVRRMoHhTERKTV169bl5Zdfpnfv3iQlJdGuXTu+/vprqlatyvPPP895553HGWecQcOGDfOc/8knn2Tq1Km0bt2aNm3a8OWXX3Lsscdy+umnk5iYyODBg+natSt9+vShffv2tG7dmt/97nds3LiR1NRULr/8clJSUrjkkks488wz81xHenp67Erfbt268dhjj/GrX/2KgQMH0rJlS1JTU0lMTOTqq68+aGvUoEGD6NGjB2effXahXq+77rqLnTt3kpSURGJiInfddddB5xk0aBBJSUm6KbIUyYABA6hXrx6JiYmxspz3T0pKCo0aNYp1S9ixYwf9+/endevWJCcnM23aNCD4snXeeefRvHlzWrVqleuq6O+//57OnTuTlJREp06dyMrKKtXtK2v0Q+GSb3Zf+bzJqt9TPvfxsuyrr76iRYsWUVdDCkj/N8mv6dOnU716dfr27cv8+fP3GX/LLbdQs2ZN7r77bp555hkyMjJ46aWXWLlyJT169GDOnDls27aNWbNmcfbZZ7Njxw46d+7MHXfcQY8ePbj00ks5//zz6devHx9++CEvvfQSr776agRbWnoO9EPhahkTERGRXDp27Ejt2rXzHOfuvPHGG7Ebci9YsIDOnTsDUK9ePY455hgyMjKoVq1arFW4SpUqpKamxlrA4uc5++yzeeedd0p6k8o0hTERERHJtxkzZnDcccfFrn5OTk7mnXfeITs7myVLljB37lyWL1+ea55169bx73//OxbAkpOTGTduHADjx49n48aNrFmzpnQ3pAxRGBMREZF8GzNmTKxVDIL+ZQkJCaSlpXHjjTfSoUMHKlXac7OG7OxsevfuzQ033MCvf/1rAB5//HE++ugjTjnlFD766COOP/74XPMcbg7fLRcREZECyc7O5q233mLu3LmxskqVKvHEE0/Ehjt06BBrNYPgopImTZpw4403xsoaNGjAW2+9BQT3Ahw3blzsvnmHI7WMiYiISL68//77NG/ePHaTYwiumsy5zcuUKVOoVKkSLVu2BOAvf/kL69evZ9iwYbmWs3r16thv1T788MMMGDCglLagbFIYExERkVx69+5N+/btWbhwIQkJCYwcORKAsWPH5jpFCbBy5UpSU1Np0aIFjzzySOyqyKysLB588EEWLFhAamoqKSkpvPjii0Bws+RmzZrRtGlTfv75Z+68887S3cAyRre2kHzTrS0kR7HdIqGY7rofk4/jmZlx880387e//Q0I+q5s2rSJe++9t1ir8tBDD3HHHXfEhjt06MAnn3xSrOsoKN3aQiQ6urWFiEjoiCOO4K233mL16tUlup6HHnoo13DUQUxEyi6FMRE5rFSqVIlBgwbl6nCcY9WqVVxyySW0bduWtm3b8vHHH8fKu3TpQmpqKldffTUNGzaMhbmLLrqINm3a0KpVq9iPmw8ZMiT2w+k5d8KvXr06ENzFfOLEibF1XnnllYwbN45du3YxePBg2rZtS1JSEs8991yJvg4iUnYojInIYee6667jtddeY/369bnK//SnP3HTTTcxZ84cxo0bx8CBAwG47777OOecc/jss8/o2bMny5Yti80zatQo5s6dS0ZGBsOHD2fNmjUMHTo09sPpr732Wq519OrVi9dffx0Ifkbmgw8+4Nxzz2XkyJHUrFmTOXPmMGfOHF544QWWLFlSwq+EiJQFurWFiBx2atSoQd++fRk+fDhHHnlkrPz9999nwYIFseENGzawceNG/vOf/zB+/HgAunfvTq1atWLTDB8+PDZu+fLlLFq0iGOPPXa/6+7Rowc33HAD27dvZ/LkyXTs2JEjjzyS9PR0vvjiC958800A1q9fz6JFi2jcuHGxbruIlD0KYyJyWLrxxhtJTU2lf//+sbLdu3czc+bMXAENgp9/ycu0adN4//33mTlzJtWqVaNTp05s27btgOutWrUqnTp14r333uP111+PXZnm7jz11FN069atiFsmIuWNwpiIHJZq167NZZddxsiRI2P3OOratStPP/00gwcPBiAzM5OUlBTOOOMM3njjDW677TbS09NZu3YtELRe1apVi2rVqvH111/z6aefxpZfuXJldu7cSeXKlfdZd69evXjxxRfJyMjg5ZdfBqBbt26MGDGCc845h8qVK/PNN99w/PHHc9RRR5XwKyGHI10dX7aoz5iIRMe9eB8FdMstt+S6qnL48OFkZGSQlJREy5YtefbZZwG45557SE9PJzU1lUmTJlG/fn2OPvpounfvTnZ2NklJSdx11120a9cutqxBgwaRlJQU68Afr2vXrkyfPp3f/OY3VKlSBYCBAwfSsmVLUlNTSUxM5OqrryY7O7vA2yQi5Y/uMyb5pm9SkuNwu1/V9u3bqVixIpUqVWLmzJlce+21ZGZmRl2tAjvc/m+yfzqel74D3WdMpylFRA5i2bJlXHbZZezevZsqVarwwgsvRF0lETmEKIyJiBxEkyZN+Pzzz6OuhogcotRnTERERCRCBw1jZjbKzFaa2fy4stfNLDN8LDWzzLC8kZltjRv3bNw8bczsv2a22MyGmwU/Smdmtc1sipktCv/W2rcWIiIiIoem/LSMvQx0jy9w98vdPcXdU4BxwFtxo7/NGefu18SVjwAGAU3CR84yhwAfuHsT4INwWEREROSwcNAw5u7TgV/yGhe2bl0GjDnQMsysPlDD3Wd6cPnmK8BF4egLgdHh89Fx5SIiIiKHvKJ24D8T+NndF8WVNTazz4ENwF/cfQZwPJAVN01WWAZwnLuvAHD3FWZWb38rM7NBBK1rnHjiiUWsuohErbgvr8/PZe8VK1akdevWZGdn06JFC0aPHk21atUKtJ6BAwdy880307JlSx566CHuuOOO2LgOHTrwySefFLjuInL4KmoH/t7kbhVbAZzo7qcANwP/NLMaQF5H3ALfLMTdn3f3NHdPq1u3bqEqLCKHt5wf8J4/fz5VqlSJ3di1IF588UVatmwJwEMPPZRrnIKYiBRUocOYmVUCLgZezylz9+3uviZ8Phf4FmhK0BKWEDd7AvBj+Pzn8DRmzunMlYWtk4hIQZx55pksXrwYgL///e8kJiaSmJjIsGHDANi8eTPnnXceycnJJCYm8vrrweGuU6dOZGRkMGTIELZu3UpKSkrsTvvVq1cH4PLLL2fixImxdV155ZWMGzeOXbt2MXjwYNq2bUtSUhLPPfdcaW6yiJRBRTlN+Rvga3ePnX40s7rAL+6+y8x+TdBR/zt3/8XMNppZO2AW0Bd4KpxtAtAPGBr+facIdRIRyZfs7GwmTZpE9+7dmTt3Li+99BKzZs3C3TnttNM466yz+O6772jQoAH/93//BwS/RRlv6NChPP3003nejb9Xr168/vrrnHvuuezYsYMPPviAESNGMHLkSGrWrMmcOXPYvn07p59+Ol27dqVx48alst0iUvbk59YWY4CZQDMzyzKzq8JRvdi3435H4Aszmwe8CVzj7jmd/68FXgQWE7SYTQrLhwJdzGwR0CUcFhEpETktWWlpaZx44olcddVV/Oc//6Fnz54cddRRVK9enYsvvpgZM2bQunVr3n//fW677TZmzJhBzZo1872eHj168OGHH7J9+3YmTZpEx44dOfLII0lPT+eVV14hJSWF0047jTVr1rBo0aKDL1BEDlkHbRlz9977Kb8yj7JxBLe6yGv6DCAxj/I1QOeD1UNEpDjk9BmLt7/f6G3atClz585l4sSJ3H777XTt2pW77747X+upWrUqnTp14r333uP111+nd+/esXU99dRTdOvWrWgbIiKHDN2BX0QOex07duTtt99my5YtbN68mfHjx3PmmWfy448/Uq1aNX7/+99z66238tlnn+0zb+XKldm5c2eey+3VqxcvvfQSM2bMiIWvbt26MWLEiNg833zzDZs3by65jRORMk+/TSkikcnPrShKQ2pqKldeeSWnnnoqENy64pRTTuG9995j8ODBVKhQgcqVKzNixIh95h00aBBJSUmkpqby2muv5RrXtWtX+vbtywUXXECVKlViy166dCmpqam4O3Xr1uXtt98u+Y0UkTLL9tc8X9alpaV5RkZG1NU4rBT3PaFKS1n5wD+UfPXVV7Ro0SLqakgB6f8mOXQ8L31mNtfd0/Iap9OUIiIiIhFSGBMRERGJkMKYiBRKee3icLjS/0uk7FIYE5ECq1q1KmvWrNEHfDnh7qxZs4aqVatGXRURyYOuphSRAktISCArK4tVq1ZFXRXJp6pVq5KQkHDwCUWk1CmMiUiBVa5cWT/fIyJSTHSaUkRERCRCCmMiIiIiEVIYExEREYmQwpiIiIhIhBTGRERERCKkMCYiIiISIYUxERERkQgpjImIiIhESGFMREREJEIKYyIiIiIRUhgTERERiZDCmIiIiEiEFMZEREREIqQwJiIiIhIhhTERERGRCCmMiYiIiERIYUxEREQkQgpjIiIiIhFSGBMRERGJkMKYiIiISIQUxkREREQipDAmIiIiEiGFMREREZEIKYyJiIiIREhhTERERCRCCmMiIiIiEVIYExEREYmQwpiIiIhIhBTGRERERCKkMCYiIiISoYOGMTMbZWYrzWx+XNm9ZvaDmWWGj3Pjxt1uZovNbKGZdYsr7x6WLTazIXHljc1slpktMrPXzaxKcW6giIiISFmWn5axl4HueZQ/4e4p4WMigJm1BHoBrcJ5/mFmFc2sIvAM0ANoCfQOpwV4JFxWE2AtcFVRNkhERESkPDloGHP36cAv+VzehcBYd9/u7kuAxcCp4WOxu3/n7juAscCFZmbAOcCb4fyjgYsKuA0iIiIi5VZR+oz90cy+CE9j1grLjgeWx02TFZbtr/xYYJ27Z+9VniczG2RmGWaWsWrVqiJUXURERKRsKGwYGwGcBKQAK4C/heWWx7ReiPI8ufvz7p7m7ml169YtWI1FREREyqBKhZnJ3X/OeW5mLwDvhoNZwAlxkyYAP4bP8ypfDRxjZpXC1rH46UVEREQOeYVqGTOz+nGDPYGcKy0nAL3M7Agzaww0AWYDc4Am4ZWTVQg6+U9wdwemAr8L5+8HvFOYOomIiIiURwdtGTOzMUAnoI6ZZQH3AJ3MLIXglOJS4GoAd//SzN4AFgDZwHXuvitczh+B94CKwCh3/zJcxW3AWDN7APgcGFlsWyciIiJSxuXnasre7l7f3Su7e4K7j3T3/3H31u6e5O4XuPuKuOkfdPeT3L2Zu0+KK5/o7k3DcQ/GlX/n7qe6+8nufqm7by/+zSxfBgwYQL169UhMTNxn3OOPP46ZsXr1agC+/vpr2rdvzxFHHMHjjz8em27btm2ceuqpJCcn06pVK+65557YuA8//JDU1FQSExPp168f2dnZ+6xHRERESofuwF8GXXnllUyePHmf8uXLlzNlyhROPPHEWFnt2rUZPnw4t956a65pjzjiCD788EPmzZtHZmYmkydP5tNPP2X37t3069ePsWPHMn/+fBo2bMjo0aNLfJtEREQkbwpjZVDHjh2pXbv2PuU33XQTjz76KMHt2QL16tWjbdu2VK5cOde0Zkb16tUB2LlzJzt37sTMWLNmDUcccQRNmzYFoEuXLowbN64Et0ZEREQORGGsnJgwYQLHH388ycnJ+Z5n165dpKSkUK9ePbp06cJpp51GnTp12LlzJxkZGQC8+eabLF++/CBLEhERkZKiMFYObNmyhQcffJD779a9qKQAACAASURBVL+/QPNVrFiRzMxMsrKymD17NvPnz8fMGDt2LDfddBOnnnoqRx99NJUqFeoOJyIiIlIMFMbKgW+//ZYlS5aQnJxMo0aNyMrKIjU1lZ9++ilf8x9zzDF06tQp1g+tffv2zJgxg9mzZ9OxY0eaNGlSktUXERGRA1AYKwdat27NypUrWbp0KUuXLiUhIYHPPvuMX/3qV/udZ9WqVaxbtw6ArVu38v7779O8eXMAVq5cCcD27dt55JFHuOaaa0p+I0RERCRPCmNlUO/evWnfvj0LFy4kISGBkSP3f+u1n376iYSEBP7+97/zwAMPkJCQwIYNG1ixYgVnn302SUlJtG3bli5dunD++ecD8Nhjj9GiRQuSkpL47W9/yznnnFNamyYiIiJ7seAm+OVPWlqa53RCl9Jh9+X1U6Jln99TPvdxESn/BgwYwLvvvku9evWYPz/4sZq77rqLd955hwoVKlCvXj1efvllGjRowGOPPcZrr70GQHZ2Nl999RWrVq2idu3aTJ48mT/96U/s2rWLgQMHMmTIEACefvpphg0bxrfffsuqVauoU6dOvuql43npM7O57p6W1zi1jImIiJSQvO4bOXjwYL744gsyMzM5//zzYxdnDR48mMzMTDIzM3n44Yc566yzqF27Nrt27eK6665j0qRJLFiwgDFjxrBgwQIATj/9dN5//30aNmxY6tsmxUdhTEREpITkdd/IGjVqxJ5v3rw5170jc4wZM4bevXsDMHv2bE4++WR+/etfU6VKFXr16sU77wQ/43zKKafQqFGjktsAKRW6p4GIiEgpu/POO3nllVeoWbMmU6dOzTVuy5YtTJ48maeffhqAH374gRNOOCE2PiEhgVmzZpVqfaVkqWWstJmV34eIiBSLBx98kOXLl3PFFVfEQleOf//735x++umxFrW8+nbn1Zom5ZfCmIiISET69Omzz0/SjR07NnaKEoKWsPhfSsnKyqJBgwalVkcpeQpjIiIipWjRokWx5xMmTIjdAxJg/fr1fPTRR1x44YWxsrZt27Jo0SKWLFnCjh07GDt2LBdccEGp1llKlsKYiIhICcnrvpFDhgwhMTGRpKQk0tPTefLJJ2PTjx8/nq5du3LUUUfFyipVqsTTTz9Nt27daNGiBZdddhmtWrUCYPjw4SQkJJCVlUVSUhIDBw4s9W2UotN9xkpbOT7Pb/dGXYPCKc/3pRERKQm6z1jp033GRERERMoohTERERGRCCmMiYiIiERIYUxEREQkQgpjIiIihRH1jbh1E+9DhsKYiIiISIQUxkREREQipDAmIiIiEiGFMREREZEIKYyJiIiIREhhTERERCRCCmMiIiIiEVIYExEREYmQwpiIiIhIhBTGRERERCKkMCYiIiISIYUxERERkQgpjImIiIhESGFMREREJEIKYyIiIiIRUhgTERERiZDCmIiIiEiEFMZEREREIqQwJiIiIhKhg4YxMxtlZivNbH5c2WNm9rWZfWFm483smLC8kZltNbPM8PFs3DxtzOy/ZrbYzIabmYXltc1sipktCv/WKokNFRERESmL8tMy9jLQfa+yKUCiuycB3wC3x4371t1Twsc1ceUjgEFAk/CRs8whwAfu3gT4IBwWEREROSwcNIy5+3Tgl73K0t09Oxz8FEg40DLMrD5Qw91nursDrwAXhaMvBEaHz0fHlYuIiIgc8oqjz9gAYFLccGMz+9zMPjKzM8Oy44GsuGmywjKA49x9BUD4t97+VmRmg8wsw8wyVq1aVQxVFxEREYlWkcKYmd0JZAOvhUUrgBPd/RTgZuCfZlYDsDxm94Kuz92fd/c0d0+rW7duYastIiIiUmZUKuyMZtYPOB/oHJ56xN23A9vD53PN7FugKUFLWPypzATgx/D5z2ZW391XhKczVxa2TiIiIiLlTaFaxsysO3AbcIG7b4krr2tmFcPnvyboqP9dePpxo5m1C6+i7Au8E842AegXPu8XVy4iIiJyyDtoy5iZjQE6AXXMLAu4h+DqySOAKeEdKj4Nr5zsCNxvZtnALuAad8/p/H8twZWZRxL0McvpZzYUeMPMrgKWAZcWy5aJiIiIlAMHDWPu3juP4pH7mXYcMG4/4zKAxDzK1wCdD1YPERERkUOR7sAvIiIiEiGFMREREZEIKYyJiIiIREhhTERERCRCCmMiIiIiEVIYExEREYmQwpiIiIhIhBTGRERERCKkMCYiIiISIYUxERERkQgpjImIiIhESGFMREREJEIKYyIiIiIRUhgTERERiZDCmIiIiEiEFMZEREREIqQwJiIiIhIhhTERERGRCCmMiYiIiERIYUxEREQkQgpjIiIFMGDAAOrVq0diYmKs7JdffqFLly40adKELl26sHbtWgCmTZtGzZo1SUlJISUlhfvvvx+AhQsXxspSUlKoUaMGw4YNA2DevHm0b9+e1q1b89vf/pYNGzaU/kaKSKlSGBMRKYArr7ySyZMn5yobOnQonTt3ZtGiRXTu3JmhQ4fGxp155plkZmaSmZnJ3XffDUCzZs1iZXPnzqVatWr07NkTgIEDBzJ06FD++9//0rNnTx577LHS2zgRiYTCmIhIAXTs2JHatWvnKnvnnXfo168fAP369ePtt9/O9/I++OADTjrpJBo2bAgErWYdO3YEoEuXLowbN66Yai4iZZXCmIhIEf3888/Ur18fgPr167Ny5crYuJkzZ5KcnEyPHj348ssv95l37Nix9O7dOzacmJjIhAkTAPjXv/7F8uXLS7j2IhI1hTERkRKSmprK999/z7x587j++uu56KKLco3fsWMHEyZM4NJLL42VjRo1imeeeYY2bdqwceNGqlSpUtrVFpFSpjAmIlJExx13HCtWrABgxYoV1KtXD4AaNWpQvXp1AM4991x27tzJ6tWrY/NNmjSJ1NRUjjvuuFhZ8+bNSU9PZ+7cufTu3ZuTTjqpFLdERKKgMCYiUkQXXHABo0ePBmD06NFceOGFAPz000+4OwCzZ89m9+7dHHvssbH5xowZk+sUJRA7xbl7924eeOABrrnmmtLYBBGJkMKYiESiILeIeO2110hKSiIpKYkOHTowb9682DyNGjWidevWpKSkkJaWFiu/6667SEpKIiUlha5du/Ljjz8WS7179+5N+/btWbhwIQkJCYwcOZIhQ4YwZcoUmjRpwpQpUxgyZAgAb775JomJiSQnJ3PDDTcwduxYzAyALVu2MGXKFC6++OJcyx8zZgxNmzalefPmNGjQgP79+xdLvUWk7LKcb23lTVpammdkZERdjYILD8Tlkd0bdQ0Kx+8pn/v4oW769OlUr16dvn37Mn/+fAD+/Oc/U7t2bYYMGcLQoUNZu3YtjzzyCJ988gktWrSgVq1aTJo0iXvvvZdZs2YBQRjLyMigTp06uZa/YcMGatSoAcDw4cNZsGABzz77bOlupBzadDwvdeX5eG5mc909La9xahkTkUgU5BYRHTp0oFatWgC0a9eOrKysgy4/J4gBbN68OdYiJSJS1lSKugIiIjkOdIuIHCNHjqRHjx6xYTOja9eumBlXX301gwYNio278847eeWVV6hZsyZTp04t+Q0QESkEtYyJSLkxdepURo4cySOPPBIr+/jjj/nss8+YNGkSzzzzDNOnT4+Ne/DBB1m+fDlXXHEFTz/9dBRVFhE5KLWMiUiZkXOLiPr16+e6RQTAF198wcCBA5k0aVKuKxIbNGgAQL169ejZsyezZ8+O3cE+R58+fTjvvPO47777DloHu698ns4sz31pRA53ahkTkTJjf7eIWLZsGRdffDGvvvoqTZs2jU2/efNmNm7cGHuenp4euzpz0aJFsekmTJhA8+bNS2szREQKRC1jIhKJ3r17M23aNFavXk1CQgL33XcfQ4YM4bLLLmPkyJGceOKJ/Otf/wLg/vvvZ82aNfzhD38AoFKlSmRkZPDzzz/HfmA7OzubPn360L17dwCGDBnCwoULqVChAg0bNtSVlCJSZunWFqWtHF/RpUuh5XCg05SSbzqel7ryvJ/r1hYiIiIiZZTCmIiIiEiEFMZEpPiZld+HiEgpUxgTERERiVC+wpiZjTKzlWY2P66stplNMbNF4d9aYbmZ2XAzW2xmX5hZatw8/cLpF5lZv7jyNmb233Ce4abfLREREZHDRH5bxl4Guu9VNgT4wN2bAB+EwwA9gCbhYxAwAoLwBtwDnAacCtyTE+DCaQbFzbf3ukREREQOSfkKY+4+Hfhlr+ILgdHh89HARXHlr3jgU+AYM6sPdAOmuPsv7r4WmAJ0D8fVcPeZHtxn45W4ZYmIiIgc0orSZ+w4d18BEP7N+d2S44HlcdNlhWUHKs/Ko3wfZjbIzDLMLGPVqlVFqLqIiIhI2VASHfjz6u/lhSjft9D9eXdPc/e0unXrFqGKIiIiImVDUcLYz+EpRsK/K8PyLOCEuOkSgB8PUp6QR7mIiIjIIa8oYWwCkHNFZD/gnbjyvuFVle2A9eFpzPeArmZWK+y43xV4Lxy30czahVdR9o1bloiIiMghLV8/FG5mY4BOQB0zyyK4KnIo8IaZXQUsAy4NJ58InAssBrYA/QHc/Rcz+yswJ5zufnfPuSjgWoIrNo8EJoUPERERkUNevsKYu/fez6jOeUzrwHX7Wc4oYFQe5RlAYn7qIiIiInIo0R34RURERCKkMCYiIiISIYUxERERkQgpjImIiIhESGFMREREJEIKYyIiIiIRUhgTERERiZDCmIiIiEiEFMZEREREIqQwJiIiIhIhhTERERGRCCmMiYiIiERIYUxEREQkQgpjIiIiIhFSGBMRERGJkMKYiIiISIQUxkREREQipDAmIiIiEiGFMREREZEIKYyJiIiIREhhTERERCRCCmMiIiIiEVIYExEREYmQwpiIiIhIhBTGRERERCKkMCYiIiISIYUxERERkQgpjImIiIhESGFMREREJEIKYyIiIiIRUhgTERERiZDCmIiIiEiEFMZEREREIqQwJiIiIhIhhTERERGRCCmMiYiIiERIYUxEREQkQgpjIiIiIhFSGBMRERGJkMKYiIiISIQKHcbMrJmZZcY9NpjZjWZ2r5n9EFd+btw8t5vZYjNbaGbd4sq7h2WLzWxIUTdKREREpLyoVNgZ3X0hkAJgZhWBH4DxQH/gCXd/PH56M2sJ9AJaAQ2A982saTj6GaALkAXMMbMJ7r6gsHUTERERKS8KHcb20hn41t2/N7P9TXMhMNbdtwNLzGwxcGo4brG7fwdgZmPDaRXGRERE5JBXXH3GegFj4ob/aGZfmNkoM6sVlh0PLI+bJiss21/5PsxskJllmFnGqlWriqnqIiIiItEpchgzsyrABcC/wqIRwEkEpzBXAH/LmTSP2f0A5fsWuj/v7mnunla3bt0i1VtERESkLCiO05Q9gM/c/WeAnL8AZvYC8G44mAWcEDdfAvBj+Hx/5SIiIiKHtOI4TdmbuFOUZlY/blxPYH74fALQy8yOMLPGQBNgNjAHaGJmjcNWtl7htCIiIiKHvCK1jJlZNYKrIK+OK37UzFIITjUuzRnn7l+a2RsEHfOzgevcfVe4nD8C7wEVgVHu/mVR6iUiIiJSXhQpjLn7FuDYvcr+5wDTPwg8mEf5RGBiUeoiIiIiUh7pDvwiIiIiEVIYExEREYmQwpiIiIhIhBTGRERERCKkMCYiIiISIYUxERERkQgpjImIiIhESGFMREREJEIKYyIiIiIRUhgTERERiZDCmIiIiEiEFMZEREREIqQwJiIiIhIhhTERERGRCFWKugKSt11AGnA88C5wFZABONAUeBmovtc8U4AhwA6gCvAYcA6wHbgQyAL+ED4ABgHXAqcUZ8WfAI4AjCDqXx2WzwJmh2VNgK55zDsT+Cx8flxY6crAOOBngg3/TTj+o3Ca5sVZeSkNe+/bHwK3Euy3bYCR7HtgyiTYVzcAFYE7gcvDcVcQvDcqA6cCz7Fnt7kbqA28DRwLfBvOO7YwFc9r394CvAmsA44BLgWO3Gu+JcDkuOHVwO+AFsB3QDrBG7sKcFFY0VnhRtUEehG8IN8DXwHdC1N5KW2FOYbPJjguE053L9ATWA70BX4i2PUGAX8Kp7sNmASkAK+EZa8Cv8RNUyBFOYZvBSYAK8P5LwROAFYQvAjZ4fznAQnAAmAqwXumF1AtrPgHBO+lw4jCWBn1JMGxekM4/ARQI3x+M/A0QfCKVwf4N9AAmA90A34A3iP4kJsIpBKEsXnAboo5iOXoBxwVN7wE+Jrg07QSsCmPeTYQvNmvI/gkfSPciPrh+D8Ao4BtwE6CDTurBOouJS5+395NsLt8QPABdTcwmuCDK141gg+aJsCPBPtzN4L8cwXwv+F0fYAXCXa1vwGfEgSvfwLXA38B/lqUyu+9b/8HaAycCcwIh7vsNU/jsEIQhLfhwEnh8LtAb6AuwQfddIJP38/CeaYSJMim4bjfFaXyUpoKcwxPJAhslQjySzLw23D4bwTH740E+38XgqD3CfAFwfvgv8DJBEFvMkVQmGM44UpPJvimlE1wrIagpaATwRv4m3C4f1j5gQTH+v8CpxF8OzunKJUvn3SasgzKAv6PYB/NkfMmdoIvH5bHfKcQBDGAVgS5ZTtBttlK8N7IcRdwf/FV+cDmAGewJ/rv/XUwx26CN++u8O/RBM0gO8Nxuwg2fCpwdgnWV0rM3vv2GoIv4U3D4S4ELVp7a0pwHIdgH68HrAqHzyXYLYygZSwrLK9AsP9vIXgPzCDI9jnLKRYLCZokCP9+fZDpF4QVqBIOW1hJwr9Hx02b836oQPDtqQn7trpJmVTYY3g19hwmt8VNU58giEGwi7Qg+D5agaBFOWeZlQnOiNwQPi82+TmGbyNovc2paCX27K/728+NPaGtQjh/dYLW4cOMWsbKoBuBRwm+AcXrT9C61ZLgW9KBjCMIZ0cQfMC9SvCl488Ercht2BPcipWFK7NwJWkEn7jLCL7xVCJo3j5+r/lqAB0Ivj5WJmg5ODkcV5Pg3FMyQRO2s6fFTMqVvfftOgTH4QyCXeVNglMyBzKb4APopL3KdxLsek+Gw/cQtJ41IGg5u4xCnp7Mkde+vYk9HyxHA5sPsoz5QPu44QuA1wjeF0ew59O7A0ETX13gxLDivy9K5aU0FeUYPgsYQJBLXmXfD+mlwOcEx/OjgUsIjvWdCQ6VcwhamAutsMfwtQRp8m2CbiX1gR4EXzy6h8vMOSWf0/TdieDNeTRwMfAvDtvWX4WxMuZdgm/9bYBpe417iaBx6HrgdYI3dl6+JOhHkB4OVyI4TQPBB1Y3gkB2M8H7qy/BZ0KxGEAQrDYRvPnqEHzD30rwQfMDwRvuT+T+ariVoFXhRqAqwWnKeQQBrEfcdP8Ezic4ZfMTwSdym+KqvJSkvPZtI8gZNxF8Ye7KgQ9KK4D/ITiVuXez/h+AjgRnDCH4EpJzxnA0QQvaQuBxoBZBaKtWkA3Ia98uiI0EfWlOjiubSXB+KQH4mKBPwYUE+31yOM00gk/eRQTviZoEL5TOa5RJRT2Gn0ZwDP+K4GxhD4JDIgS73iXAMPa0tP05fEBwiL2fIMenA0kEp+YLpLDH8N0Eb9BzCfbnSQSn7c8hSIjdCVLofOCdcONOYs+3qkyC1t/VBKcvjwznqcJhQW/nMuZjgqDUiKA/44fk/kJckeB0fF6nciBoHu9J0L9m75YDgH8QvAdmEuzjrwMPFEO9Y3KOENUJOtf/EJa1IHjjJoR/t+w133cEn5BHEWxkC/ZtIvmaoJljJ8GH2mUEH047inMDpKTsb99uT3AKcTZBmNrfacQNBP1+HwDa7TXuPoLTln/PY74tBGHsD8DtBF0P2xA0SBVIXvt2dfY0f2wkdz+bvX0ZzlcxHN5M0IKQEA63Yt99fkO4nuYEX0AuDedfUtDKS2kp6jE8RwuC3Wl+OLyTIIhdQdCItLfPw79NCY7/Od1uFxV0Awp7DK8RPnL255YE4QyC43SL8HmrcJnxdhCEsbYEHUgvJGhZ+29BK19+KYyVMQ8TBKqlBC0G5xB8OVkcjneCTvp5XUS4juDD6mHg9DzGryX41taX4H1UgeA9ta24Kr+DPf0CdhB0PK4XVjbnw2M1wVfDvZskahJseE4HiCUEp2hy7CLojd2BPZ1CCafdVVwbICUpr337fwlyNQS7ziPANXnMu4PgS0Zf9r3I6kWCBqUx5H1Ae5TgS3xO38mci8T2/iw5oP3t280IPkQI/zY7wDL+C7SOG65K8OZbHQ5/R+59HoL+kTmdmXM6fRq53wNSphTlGL6EPf/m7wlachux58xeC4IzGnnJ6Qec0+0WinE/z88x/GiC43he+/PRBC8I4XL27hP2McE3rJw+wjmdQA+j/VynKcsBJ2jN2hA+TwZGhOMmEPS3uZ/g6pzFBFeL5Vwxlk7wXiKc5i8E+3g34BmCz4a8PvwKZRNBUxsETdatCZo5sgmapZ8heLNdFFZiQ7gBvyf4NtWSoG9YBYJvRfGnH2cTdJCuQnBLCwia+dSpudx7jOBLwm6Ci7VyskcG8CxB2HqDoGFoDcGVYoR/Uwj234bs6Yp1MXv6zPwYLufecPgWgmP+MQRdW/Jtf/v28QSnbD4n+CDKSYo/hCu+MBxeS7C/N4xbZkWC/gFvELwfqsZND3taFXL6R55C8MavQdDXRsqN/B7D/wMMJfjiUIHgEFcnLH+VYLfLuV7kIYIzghDsy23Z0w+4fThtEnvOdudLUY7hEJxTHUcQ1mqF00FwSejkcJmVwuEcGwjeqDkXZeX0l6xK0LR4mDB3j7oOhZKWluYZGRlRV6PgLK9raMoHuzfqGhSO31M+9/FyTft5qdN+HgHt56WuPO/nZjbX3dPyGqfTlCIiIiIRUhgTERERiZDCmIiIiEiEFMZEREREIqQwJiIiIhIhhTERERGRCCmMiYiIiERIYUxEREQkQgpjIiIiIhFSGBMRERGJkMKYiIiISIQUxkREREQipDAmIiIiEiGFMREREZEIKYyJiIiIREhhTERERCRCRQ5jZrbUzP5rZplmlhGW1TazKWa2KPxbKyw3MxtuZovN7AszS41bTr9w+kVm1q+o9RIREREpD4qrZexsd09x97RweAjwgbs3AT4IhwF6AE3CxyBgBAThDbgHOA04FbgnJ8CJiIiIHMpK6jTlhcDo8Plo4KK48lc88ClwjJnVB7oBU9z9F3dfC0wBupdQ3URERETKjOIIYw6km9lcMxsUlh3n7isAwr/1wvLjgeVx82aFZfsrz8XMBplZhpllrFq1qhiqLiIiIhKtSsWwjNPd/UczqwdMMbOvDzCt5VHmByjPXeD+PPA8QFpa2j7jRURERMqbIreMufuP4d+VwHiCPl8/h6cfCf+uDCfPAk6Imz0B+PEA5SIiIiKHtCKFMTM7ysyOznkOdAXmAxOAnCsi+wHvhM8nAH3DqyrbAevD05jvAV3NrFbYcb9rWCYiIiJySCvqacrjgPFmlrOsf7r7ZDObA7xhZlcBy4BLw+knAucCi4EtQH8Ad//FzP4KzAmnu9/dfyli3URERETKvCKFMXf/DkjOo3wN0DmPcgeu28+yRgGjilIfERERkfJGd+AXERERiZDCmIiIiEiEFMZEREREIqQwJiIiIhIhhTERERGRCCmMiYiIiERIYUxEREQkQgpjIiIiIhFSGBMRERGJkMKYiIiISIQUxkREREQipDAmIiIiEiGFMREREZEIKYyJiIiIREhhTERERCRCCmMiIiIiEVIYExEREYmQwpiIiIhIhBTGRERERCKkMCYiIiISIYUxERERkQgpjImIiIhESGFMREREJEIKYyIiIiIRUhgTERERiZDCmIiIiEiEFMZEREREIqQwJiIiIhIhhTERERGRCCmMiYiIiERIYUxEREQkQgpjIiIiIhFSGBMRERGJkMKYiIiISIQUxkREREQipDAmIiIiEiGFMREREZEIKYyJiIiIREhhTERERCRCCmMiIiIiESp0GDOzE8xsqpl9ZWZfmtmfwvJ7zewHM8sMH+fGzXO7mS02s4Vm1i2uvHtYttjMhhRtk0RERETKj0pFmDcbuMXdP7P/396dx9hV1mEc/z6WfRFUGmULRSwSIFCgIMgiGhdUEoQQNkWICqiggUQNYIwGQiSiYESCljUYAkER0iBSlEUWFcpSlrIIAgkNiICEzbLVn3/cUx2mM9NlOvNOZ76fv+55z3vO/Z3knclzz3nvfZO1gTuT/KHbd0ZV/bhv5yRbAgcBWwEbAH9Msnm3+yzgE8A8YHaSmVX1wDBqkyRJWiEscxirqqeBp7vXLyd5ENhwiEP2AS6tqteBx5M8CuzU7Xu0qh4DSHJp19cwJkmSxr3lMmcsyRRgO+C2rumYJPcmOT/Ju7q2DYEn+xw2r2sbrH2g9zkyyR1J7nj22WeXR+mSJElNDTuMJVkLuBw4tqpeAs4GNgOm0btz9pOFXQc4vIZoX7SxakZVTa+q6ZMnTx5u6ZIkSc0NZ84YSVamF8QurqrfAlTVM332nwNc1W3OAzbuc/hGwFPd68HaJUmSxrXhfJsywHnAg1V1ep/29ft02xe4v3s9EzgoyapJNgWmArcDs4GpSTZNsgq9Sf4zl7UuSZKkFclw7oztChwK3JdkTtd2InBwkmn0HjU+ARwFUFVzk1xGb2L+W8DRVbUAIMkxwCxgEnB+Vc0dRl2SJEkrjOF8m/IWBp7vdfUQx5wCnDJA+9VDHSdJkjRe+Qv8kiRJDRnGJEmSGjKMSZIkNWQYkyRJasgwJkmS1JBhTJIkqSHDmCRJUkOGMUmSpIYMY5IkSQ0ZxiRJkhoyjEmSJDVkGJMkSWrIMCZJktSQYUySJKkhw5gkSVJDhjFJkqSGDGOSJEkNGcYkSZIaMoxJkiQ1ZBiTJElqyDAmSZLUkGFMkiSpIcOYJElSQ4YxSZKkhgxjkiRJDRnG/s+YXgAABtNJREFUJEmSGjKMSZIkNWQYkyRJasgwJkmS1JBhTJIkqSHDmCRJUkOGMUmSpIYMY5IkSQ0ZxiRJkhoyjEmSJDVkGJMkSWrIMCZJktSQYUySJKkhw5gkSVJDhjFJkqSGxkwYS7JXkoeTPJrk+Nb1SJIkjYYxEcaSTALOAj4NbAkcnGTLtlVJkiSNvDERxoCdgEer6rGqegO4FNincU2SJEkjLlXVugaS7A/sVVVf6bYPBT5UVcf063ckcGS3+UHg4VEtVOsBz7UuQhphjnNNBI7z0bdJVU0eaMdKo13JIDJA2yIpsapmADNGvhwNJMkdVTW9dR3SSHKcayJwnI8tY+Ux5Txg4z7bGwFPNapFkiRp1IyVMDYbmJpk0ySrAAcBMxvXJEmSNOLGxGPKqnoryTHALGAScH5VzW1clhblI2JNBI5zTQSO8zFkTEzglyRJmqjGymNKSZKkCckwJkmS1JBhTG+TZEGSOUnuSXJXkg937VOS3N+93jPJi0nuTvJgku+3rVoa2mDjeoj+U5Ic0mf78CQ/H/lKpbdL8r4klyb5e5IHklydZPPWdWn5Moypv/lVNa2qtgVOAH44SL+bq2o7YDrwhSQ7jFqF0tJb0nG90BTgkMX0kUZUkgBXADdW1WZVtSVwIvDeEXq/MfGlvonIMKahvBN4YagOVfUqcCew2ahUJA3f/8Z1ek5Lcn+S+5Ic2PU5Fdi9u5t2XNe2QZJrkjyS5EctCteE81Hgzar6xcKGqpoD3DLQuO2eWtyY5DdJHkpycRfoSPKZru2WJD9LclXX/oMkM5JcC1yUZFJ37tlJ7k1yVNdv/SQ3dX8T9yfZvet7YZ86jlvkCrRETMHqb/Ukc4DVgPWBjw3VOcl7gJ2Bk0ehNmlZDTau9wOmAdvSWx5mdpKbgOOBb1XV3tB7TNn12w54HXg4yZlV9eSoXoUmmq3pfdjtb7BxC70xuhW9H06/Fdg1yR3AL4E9qurxJJf0O98OwG5VNb9bdvDFqtoxyarArV1Q2w+YVVWnJJkErNHVsGFVbQ2QZN3ld+kTi2FM/c2vqmkASXah90lp6wH67Z7kbuA/wKn+LpzGuMHG9W7AJVW1AHgmyZ+AHYGXBjjHdVX1YneOB4BNAMOYWhhq3N5eVfMAug8gU4BXgMeq6vHu+Ev4/zrPADOran73+pPANt2a0QDrAFPp/Tj7+UlWBq6sqjlJHgPen+RM4HfAtSNzueOfYUyDqqq/JFkPGGhh05sX3jWQViT9xvVA6+IO5vU+rxfg/0+NvLnA/gO0DzVuBxqnixvnr/Y79zeqatYib5rsAXwW+FWS06rqoiTbAp8CjgYOAL60mPfSAJwzpkEl2YLeigjPt65FWl76jeubgAO7uS+TgT2A24GXgbXbVSkBcD2wapIjFjYk2ZHenMeBxu1gHqJ3B2tKt33g4F2ZBXytuwNGks2TrJlkE+CfVXUOcB6wffeh5h1VdTnwPWD7ZblI+clOi1o4twZ6n5AOq6oF3bdsXh/iOGksG2xcXwHsAtwDFPCdqvpHkueBt5LcA1zIYr7IIo2Eqqok+wI/TXI88BrwBHAssBaLjtstBjnP/CRfB65J8hxDB7dz6T3avKub/P8s8DlgT+DbSd6k99jzi8CGwAVJFt7YOWEYlzuhuRySlkiSfYDPV9UBrWuRJC2dJGtV1StdwDoLeKSqzmhdl3q8M6bFSnISsA9weONSJEnL5ogkhwGrAHfT+3alxgjvjEmSJDXkBH5JkqSGDGOSJEkNGcYkSZIaMoxJGteSLOiznt6vk6yxlMcfu7THSNLSMIxJGu/mV9W0bv28N4CvLumB3Rp8x9Jbh0+SRoRhTNJEcjPwAYAkVya5M8ncbnFkuvZXkpyU5Dbgu8AGwA1Jbkjy5SRn9Ol7RJLTR/siJI0v/rSFpHEtyStVtVa3isTlwDVVdXaSd1fVv5KsTm8R5I9U1fNJCjiwqi7rjn8CmF5VzyVZE7gX2KKq3kzyZ+CoqrqvzdVJGg/80VdJ413fpZBupreuHsA3u6VmADYGptJbr3IBvdC2iKp6Ncn1wN5JHgRWNohJGi7DmKTxbn5VTevbkGRP4OPALlX17yQ3Aqt1u1+rqgVDnO9c4ER6iy9fsPzLlTTRGMYkTUTrAC90QWwLYOch+r4MrA08B1BVtyXZGNge2GbEK5U07jmBX9JEdA2wUpJ7gZOBvw7Rdwbw+yQ39Gm7DLi1ql4YwRolTRBO4JekpZTkKuCMqrqudS2SVnzeGZOkJZRk3SR/ozcPzSAmabnwzpgkSVJD3hmTJElqyDAmSZLUkGFMkiSpIcOYJElSQ4YxSZKkhv4Lw3RIk8hXWI8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "axAll = dfAll.iloc[:,:-1].plot(kind='bar',stacked = False, title = 'Sentiment for all tweets', mark_right = False,  figsize=(10,7), color = 'rg')\n",
    "\n",
    "for p in axAll.patches:\n",
    "    width1 = p.get_width()\n",
    "    height1 = p.get_height()\n",
    "    x1, y1 = p.get_xy() \n",
    "    axAll.annotate(f'{height1}', (x1 + width1/2, y1 + height1*1.02), ha='center')\n",
    "    \n",
    "for p in axAllPercentage.patches:\n",
    "    width2 = p.get_width()\n",
    "    height2 = p.get_height()\n",
    "    x2, y2 = p.get_xy() \n",
    "    axAll.annotate(f'{height2}%', (x2 + width2/2, y2 + height1/3), ha='center', va='bottom')\n",
    "\n",
    "plt.xticks(rotation=0)\n",
    "plt.savefig('./Plots/SentimentAll.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis of Predicted Sentiment for tweets by Human accounts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th>Predicted Sentiment</th>\n",
       "      <th>Negative</th>\n",
       "      <th>Positive</th>\n",
       "      <th>Total</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Party</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BJP</th>\n",
       "      <td>12174</td>\n",
       "      <td>15627</td>\n",
       "      <td>27801</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Both</th>\n",
       "      <td>8766</td>\n",
       "      <td>8700</td>\n",
       "      <td>17466</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Congress</th>\n",
       "      <td>11627</td>\n",
       "      <td>14939</td>\n",
       "      <td>26566</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Predicted Sentiment  Negative  Positive  Total\n",
       "Party                                         \n",
       "BJP                     12174     15627  27801\n",
       "Both                     8766      8700  17466\n",
       "Congress                11627     14939  26566"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check distribution of predicted sentiment for each Human accounts only\n",
    "dfHuman = tweets2019[tweets2019['Status']=='Human'].groupby(['Predicted Sentiment','Party']).size().reset_index(name='Count').pivot(index='Party',columns='Predicted Sentiment',values='Count')\n",
    "dfHuman['Total'] = dfHuman.sum(axis=1)\n",
    "\n",
    "dfHuman_total = dfHuman['Total']\n",
    "dfHumanPercentage = round(dfHuman[dfHuman.columns[:-1]].div(dfHuman_total, 0)*100,2)\n",
    "\n",
    "dfHuman"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "axHumanPercentage = dfHumanPercentage.plot(kind='bar',stacked = False, figsize=(10,7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "axHuman = dfHuman.iloc[:,:-1].plot(kind='bar',stacked = False, title = 'Sentiment for Human tweets', mark_right = False,  figsize=(10,7), color = 'rg')\n",
    "\n",
    "for p in axHuman.patches:\n",
    "    width1 = p.get_width()\n",
    "    height1 = p.get_height()\n",
    "    x1, y1 = p.get_xy() \n",
    "    axHuman.annotate(f'{height1}', (x1 + width1/2, y1 + height1*1.02), ha='center')\n",
    "    \n",
    "for p in axHumanPercentage.patches:\n",
    "    width2 = p.get_width()\n",
    "    height2 = p.get_height()\n",
    "    x2, y2 = p.get_xy() \n",
    "    axHuman.annotate(f'{height2}%', (x2 + width1/2, y2 + height1/3), ha='center', va='bottom')\n",
    "    \n",
    "plt.xticks(rotation=0)\n",
    "plt.savefig('./Plots/SentimentHuman.png')"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}