Logistic Regression and Naive Bayes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading and plotting the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "df = pd.read_csv(\"C:\\\\Users\\\\Win 1809 UEFI\\\\Desktop\\\\99.csv\", header=0, delimiter=\",\", quoting=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head(4)\n",
    "#Converting the sentiment to numerical data to plot the histogram\n",
    "for i in range(len(df)):\n",
    "    if df.Recommended[i]=='1':\n",
    "        df.loc[i,'Recommended'] = int(1)\n",
    "    elif df.Recommended[i]=='0':\n",
    "        df.loc[i,'Recommended'] = int(-1)\n",
    "  #  elif df.airline_sentiment[i]=='Neutral':\n",
    "   #     df.loc[i,'Sentiment'] = int(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing mentons and URLs and converting # to _hashtag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import re\n",
    "regexp_mention = '(?<=^|(?<=[^a-zA-Z0-9-_\\.]))@([A-Za-z]+[A-Za-z0-9]+)'\n",
    "pattern_mention = re.compile(regexp_mention, re.UNICODE | re.IGNORECASE)\n",
    "\n",
    "for i in range(len(df)):\n",
    "    df.loc[i,'review']  = pattern_mention.sub(\"\", df.review[i])\n",
    "#print(df.TextnoMen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "regexp_url = 'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'\n",
    "pattern_url = re.compile(regexp_url, re.UNICODE | re.IGNORECASE)\n",
    "\n",
    "for i in range(len(df)):\n",
    "    df.loc[i,'review']  = pattern_url.sub(\"\", df.review[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "regexp_hashtag = '(?<=^|(?<=[^a-zA-Z0-9-_\\.]))#([A-Za-z]+[A-Za-z0-9]+)'\n",
    "pattern_hashtag = re.compile(regexp_hashtag, re.UNICODE | re.IGNORECASE)\n",
    "\n",
    "for i in range(len(df)):\n",
    "    df.loc[i,'review'] = pattern_hashtag.sub(r'hashtag_\\1', df.review[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics  import accuracy_score, classification_report, confusion_matrix, precision_score, recall_score, f1_score\n",
    "\n",
    "#Creating different datasets based on Airline\n",
    "df = df.sample(frac=1, random_state= 100)\n",
    "\n",
    "#print(df.airline.unique())\n",
    "#dfUnited = df[df.airline=='United']\n",
    "#dfAmerican = df[df.airline=='American']\n",
    "#dfSouthwest = df[df.airline=='Southwest']\n",
    "#dfDelta = df[df.airline=='Delta']\n",
    "#dfUSAir = df[df.airline=='US Airways']\n",
    "#dfVirgin = df[df.airline=='Virgin America']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function for Logistic Regression model with 10-fold cross validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "def CreateModelLR(df):\n",
    "    \n",
    "    df_text = df['review']\n",
    "    df_sentiment = df['Recommended']\n",
    "    \n",
    "    Accuracylist = []\n",
    "    f1scorelist = []\n",
    "    CVaccuracy = []\n",
    "    CVf1Score = []\n",
    "    \n",
    "    kf = KFold(n_splits=10, shuffle = True, random_state = 2)\n",
    "    \n",
    "    \n",
    "    for i in range(1,10) : \n",
    "        for train, valid in kf.split(df_sentiment):\n",
    "\n",
    "            X_train_text = df_text.iloc[train]\n",
    "            yTrain = df_sentiment.iloc[train]\n",
    "\n",
    "            X_valid_text = df_text.iloc[valid]\n",
    "            yValid = df_sentiment.iloc[valid]\n",
    "\n",
    "            #print(\"Total number of records = %d\" %len(df))\n",
    "            #print(\"Train and Test : %s and %s\" %(yTrain.shape, yValid.shape))\n",
    "\n",
    "            vect = CountVectorizer(binary = False, min_df = 5, stop_words = 'english')\n",
    "\n",
    "            XTrain = vect.fit_transform(X_train_text)\n",
    "            #print(XTrain.shape)\n",
    "\n",
    "            XValid = vect.transform(X_valid_text)\n",
    "            #print(XValid.shape)\n",
    "\n",
    "            LogR = LogisticRegression(C = 5)\n",
    "            LogR.fit(XTrain, yTrain)\n",
    "\n",
    "            Predited = LogR.predict(XValid)\n",
    "\n",
    "            Accuracylist.append(accuracy_score(yValid, Predited))\n",
    "            f1scorelist.append(f1_score(yValid, Predited, average = \"weighted\"))\n",
    "\n",
    "            performance=[]\n",
    "            f1Score = np.array(f1scorelist).mean(0)\n",
    "            Accuracy = np.array(Accuracylist).mean(0)\n",
    "        \n",
    "        CVaccuracy.append(Accuracy)\n",
    "        CVf1Score.append(f1Score)\n",
    "    #performace = [Acuracy,f1Score]\n",
    "    #print(CVaccuracy)\n",
    "    #print(CVf1Score)\n",
    "    minAccidx = np.array(CVaccuracy).argmax()\n",
    "   \n",
    "    airline = set(df.airline)\n",
    "    print(\"LOGISTIC REGRESSION\")\n",
    "    print(\"Airlines = %s ; Best Cross validation Accuracy of the model is %f ; F1-Score is %f\" % (airline,CVaccuracy[minAccidx],CVf1Score[minAccidx]))\n",
    "    print(\"----------------------------------------------------------------------------------------------\")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function for Naive Bayes model with 10-fold cross validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.naive_bayes import BernoulliNB, MultinomialNB, GaussianNB\n",
    "def CreateModelNB(df):\n",
    "    \n",
    "    df_text = df['review']\n",
    "    df_sentiment = df['Recommended']\n",
    "    \n",
    "    Accuracylist = []\n",
    "    f1scorelist = []\n",
    "    CVaccuracy = []\n",
    "    CVf1Score = []\n",
    "    \n",
    "    kf = KFold(n_splits=10, shuffle = True, random_state = 2)\n",
    "    alpha = [1e-8, 5e-8,1e-7, 5e-7,1e-6, 5e-6,1e-5, 5e-5,1e-4, 5e-4,1e-3, 5e-3,1e-2, 5e-2,1e-1, 5e-1 ]\n",
    "    \n",
    "    for i in alpha : \n",
    "        for train, valid in kf.split(df_sentiment):\n",
    "\n",
    "            X_train_text = df_text.iloc[train]\n",
    "            yTrain = df_sentiment.iloc[train]\n",
    "\n",
    "            X_valid_text = df_text.iloc[valid]\n",
    "            yValid = df_sentiment.iloc[valid]\n",
    "\n",
    "            #print(\"Total number of records = %d\" %len(df))\n",
    "            #print(\"Train and Test : %s and %s\" %(yTrain.shape, yValid.shape))\n",
    "\n",
    "            vect = CountVectorizer(binary = False, min_df = 5, stop_words = 'english')\n",
    "\n",
    "            XTrain = vect.fit_transform(X_train_text)\n",
    "            #print(XTrain.shape)\n",
    "\n",
    "            XValid = vect.transform(X_valid_text)\n",
    "            #print(XValid.shape)\n",
    "\n",
    "            MNB = MultinomialNB(i)\n",
    "            MNB.fit(XTrain, yTrain)\n",
    "\n",
    "            Predited = MNB.predict(XValid)\n",
    "\n",
    "            Accuracylist.append(accuracy_score(yValid, Predited))\n",
    "            f1scorelist.append(f1_score(yValid, Predited, average = \"weighted\"))\n",
    "\n",
    "            performance=[]\n",
    "            f1Score = np.array(f1scorelist).mean(0)\n",
    "            Accuracy = np.array(Accuracylist).mean(0)\n",
    "        \n",
    "        CVaccuracy.append(Accuracy)\n",
    "        CVf1Score.append(f1Score)\n",
    "    #performace = [Acuracy,f1Score]\n",
    "    #print(CVaccuracy)\n",
    "    #print(CVf1Score)\n",
    "    minAccidx = np.array(CVaccuracy).argmax()\n",
    "    \n",
    "    airline = set(df.airline)\n",
    "    print(\"NAIVE BAYES\")\n",
    "    print(\"Airlines = %s ; Best Cross validation Accuracy of the model is %f ; F1-Score is %f\" % (airline,CVaccuracy[minAccidx],CVf1Score[minAccidx]))\n",
    "    print(\"----------------------------------------------------------------------------------------------\")\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## All Airlines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEICAYAAABI7RO5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAGlRJREFUeJzt3Xu0JWV95vHvA03kGgEBA82l1Wmj4EqQdICMuZAgF5mlaEaMTCJIiGQUk5g4WaJhQo/GxMyoGCdGhZEBREVJoraKkpaIxDgojSFcRGMLCG230AgCisGAv/mj3mM2zelzqrrPPhfO97PWXl311ltVv9pn9352XXbtVBWSJPW1zVwXIElaWAwOSdIgBockaRCDQ5I0iMEhSRrE4JAkDWJwaFFLckWS35qDeW9N8uwtmXeSZe2Q5GNJ7k1yyUwsc5r1/Wi7k7w0yee2Ylk3Jjliiukrk1zUhvdP8t0k227p+jQzDI7HuPYG9f32H+5bSc5PsvNc16V+khyRZN003V4IPBF4QlWdMAtlDZJkp/b6u3TTaVV1UFVd0Wc5VXVbVe1cVQ/PeJEaxOBYHJ5bVTsDBwPPBF47x/VoZh0A/EtVPTR0xiRLxlDPpl4IPAgcnWTvvjPNUm3aAgbHIlJV3wIuowsQAJI8Lsmbk9yW5I4k70qyw8j045Ncm+S+JF9Pcmxr3yfJqiR3J1mb5GUj86xMckmSi5Lcn+T6JE9N8tokdya5PcnRI/2vSPInST7fPpl+LMkTkryvrffqJMtG+j8tyeq27q8medHItPOTvCPJJ9q6v5DkKSPTj0rylXZY5y+BjD5HSX4zyU1J7klyWZID+s67yXJWJvnrJB9sdXwpyU9vpu/jkrwtyfr2eFtr2wn4JLBPe16+m2SfTeb9H8AfA7/Wpp+aZJskZyb5Rnu+L0zy+NZ/WZJq/W4D/n6SenZL8vEkG9vz8PEk+25uW3s4GXgXcB3w65us60eH7Eaes4uS3Ae8dJO+E7UvaeNXJHlDkn9sz/HfJdljpP/h7TX1nST/nJFDYukOsd3c5rslySPq0jSqysdj+AHcCjy7De8LXA/8xcj0twGrgN2BXYCPAX/Wph0K3AscRfchYynwtDbts8BfAdvTBdFG4Mg2bSXwr8AxwBLgQuAW4I+A7YCXAbeM1HAFsBZ4CvB44MvAvwDPHpn//7a+OwG3A6e0aYcAdwEHtennA3e32pcA7wMubtP2AO6j+wS8HfD7wEPAb7Xpz291PL3Neybw+T7zTvK8rwT+baT/f2vPwXaT/F1eD1wF7AXsCXweeEObdgSwbpq/8UrgopHx32zb8WRgZ+Bvgfe2acuAas/pTsAOkyzvCcB/BnZsr4lLgI9s8veaeM5eCnxuitr2B34IHAi8GrhuitfnxHP2fLrX2w6j2zZS+5KROr4OPLX1vQJ4U5u2FPg2cFxb1lFtfM+23fcBP9n67k17/fjo+b4y1wX4GPMfuPuP+V3g/vaf7nJg1zYtwPeAp4z0/znamzrwbuDsSZa5H/AwsMtI258B57fhlcDqkWnPbTVs28Z3abVM1HEF8Ecj/d8CfHKT+a9tw78G/MMm9bwbOKsNnw/8n5FpxwFfacMnAVeNTAuwbuRN8JPAqSPTtwEeoDsUNOW8kzxHKzfpvw2wAfiFkb/LxBvm14HjRvoeA9zaho9geHBcDrxiZPwn6d6Ql/Dvb75PHvAaOhi4Z2T8CvoHx5kjf7t92uvmmZu8PkeD48rNbRuTB8eZI31fAXyqDb+GFpYj0y+j2/vZCfgOXTg+Kjh9TP/wUNXi8Pyq2oXuTehpdJ+eofv0tSNwTdud/w7wqdYOXUB8fZLl7QPcXVX3j7R9g+5T3oQ7Roa/D9xV/35S8/vt352n6L/p+ETfA4DDJuptNf868BMj/b81MvzAyLz70O2tAFDdu8ntI30PAP5iZLl30wXE0h7zTma0/w/pgmafSfrtQ/f8TfjGZvr1NdnyltCdQH9UbZtKsmOSd7dDXfcBVwK7ZsuuZjqJbq+PqlpPt6d68hT9p3tON7W5v/UBwAmbvE5+Hti7qr5H9wHkvwIb2mHNpw1c76JmcCwiVfVZuk/kb25Nd9G9KR9UVbu2x+OrO5EO3X/ipzx6SawHdk+yy0jb/sA3x1P5I9wOfHak3l2ru9Lm5T3m3UAXhgAkyeh4W/Zvb7LsHarq8z3mncxo/23oDhWun6Tfero3ugn7j/TbkttXT7a8h3hkGE+13FfT7aUcVlU/Dvxia9/sOZ3JJPmPwHLgtemu6PsWcBhwYjZ/4numbtd9O90ex+jfcqeqehNAVV1WVUfRHab6CnDuDK13UTA4Fp+3AUclObh9Cj4XODvJXgBJliY5pvV9D3BKkiPbCdelSZ5WVbfTHYf/syTbJ/kp4FTaJ8sx+zjw1CQvSbJde/xskqf3mPcTwEFJfrW9cf0uj9xTeRfdm9xBAEken+SEnvNO5mdG+r+K7sqiqybp9wHgzCR7tpO7fwxc1KbdATxh4uR2Tx8Afj/Jk9Jdev2nwAer/1VXu9B9oPhOkt2Bswase9TJwGq68xsHt8cz6PZyn7OFy+zrIuC5SY5Jsm17nR6RZN8kT0zyvHbxwYN0h1G9xHcAg2ORqaqNdCdG/3treg3didSr2mGJT9N92qSqvkh3EvpsupPkn+XfP8meSHfMeT3wYbpzDKtnof77gaOBF7d1fwv4c+BxPea9CzgBeBPdidLlwD+OTP9wW9bF7bm4gfYGN928m/FRukMi9wAvAX61qv5tkn5/Aqyhu+roeuBLrY2q+gpdENzcDrn0OYR1HvBeukNMt9BdqPA7Peab8Da6k8130QXdpwbMC0CS7YEXAf+7qr418ril1TbV4aqt1j7cHA+8ju7CjduBP6R7z9uGbq9qPd3hyF+iOz+intIdqpU0k5KsBP5DVf3GXNcizTT3OCRJgxgckqRBPFQlSRrEPQ5J0iCPyZuI7bHHHrVs2bK5LkOSFpRrrrnmrqrac7p+j8ngWLZsGWvWrJnrMiRpQUnyjel7eahKkjSQwSFJGsTgkCQNYnBIkgYxOCRJgxgckqRBDA5J0iAGhyRpkLEFR5L9knwmyU1Jbkzye619ZZJvJrm2PY4bmee1SdYm+erIjwmR5NjWtjbJGeOqWZI0vXF+c/wh4NVV9aX2E6PXJJn4oZ+zq+rNo52THEj34zwH0f1m8qeTPLVNfgdwFN1vNl+dZFVVfXmMtUvSVll2xifmZL23vuk/jX0dYwuOqtpA9zvNVNX9SW4Clk4xy/HAxVX1IHBLkrXAoW3a2qq6GSDJxa2vwSFJc2BWznEkWQY8E/hCa3plkuuSnJdkt9a2lO7nHSesa22ba990HaclWZNkzcaNG2d4CyRJE8YeHEl2Bv4GeFVV3Qe8E3gK3Q/XbwDeMtF1ktlrivZHNlSdU1UrqmrFnntOe3NHSdIWGuvdcZNsRxca76uqvwWoqjtGpp8LfLyNrgP2G5l9X7ofk2eKdknSLBvnVVUB3gPcVFVvHWnfe6TbC4Ab2vAq4MVJHpfkScBy4IvA1cDyJE9K8mN0J9BXjatuSdLUxrnH8SzgJcD1Sa5tba8DTkxyMN3hpluB3waoqhuTfIjupPdDwOlV9TBAklcClwHbAudV1Y1jrFuSNIVxXlX1OSY/P3HpFPO8EXjjJO2XTjWfJGn2+M1xSdIgBockaZDH5G+Ob63H8jc+JWlrucchSRrE4JAkDWJwSJIGMTgkSYMYHJKkQQwOSdIgBockaRCDQ5I0iMEhSRrE4JAkDWJwSJIGMTgkSYMYHJKkQQwOSdIgBockaRCDQ5I0iMEhSRrE4JAkDWJwSJIGMTgkSYMYHJKkQQwOSdIgBockaRCDQ5I0iMEhSRrE4JAkDWJwSJIGMTgkSYMYHJKkQcYWHEn2S/KZJDcluTHJ77X23ZOsTvK19u9urT1J3p5kbZLrkhwysqyTW/+vJTl5XDVLkqY3zj2Oh4BXV9XTgcOB05McCJwBXF5Vy4HL2zjAc4Dl7XEa8E7oggY4CzgMOBQ4ayJsJEmzb2zBUVUbqupLbfh+4CZgKXA8cEHrdgHw/DZ8PHBhda4Cdk2yN3AMsLqq7q6qe4DVwLHjqluSNLVZOceRZBnwTOALwBOragN04QLs1botBW4fmW1da9tc+6brOC3JmiRrNm7cONObIElqxh4cSXYG/gZ4VVXdN1XXSdpqivZHNlSdU1UrqmrFnnvuuWXFSpKmNdbgSLIdXWi8r6r+tjXf0Q5B0f69s7WvA/YbmX1fYP0U7ZKkOTDOq6oCvAe4qareOjJpFTBxZdTJwEdH2k9qV1cdDtzbDmVdBhydZLd2Uvzo1iZJmgNLxrjsZwEvAa5Pcm1rex3wJuBDSU4FbgNOaNMuBY4D1gIPAKcAVNXdSd4AXN36vb6q7h5j3ZKkKYwtOKrqc0x+fgLgyEn6F3D6ZpZ1HnDezFUnSdpSfnNckjSIwSFJGsTgkCQNYnBIkgYxOCRJgxgckqRBDA5J0iAGhyRpEINDkjSIwSFJGsTgkCQNYnBIkgYxOCRJgxgckqRBDA5J0iAGhyRpEINDkjSIwSFJGsTgkCQNYnBIkgYxOCRJgxgckqRBDA5J0iAGhyRpEINDkjRIr+BI8oxxFyJJWhj67nG8K8kXk7wiya5jrUiSNK/1Co6q+nng14H9gDVJ3p/kqLFWJkmal3qf46iqrwFnAq8Bfgl4e5KvJPnVcRUnSZp/+p7j+KkkZwM3Ab8CPLeqnt6Gzx5jfZKkeWZJz35/CZwLvK6qvj/RWFXrk5w5lsokSfNS3+A4Dvh+VT0MkGQbYPuqeqCq3ju26iRJ807fcxyfBnYYGd+xtW1WkvOS3JnkhpG2lUm+meTa9jhuZNprk6xN8tUkx4y0H9va1iY5o2e9kqQx6Rsc21fVdydG2vCO08xzPnDsJO1nV9XB7XEpQJIDgRcDB7V5/irJtkm2Bd4BPAc4EDix9ZUkzZG+wfG9JIdMjCT5GeD7U/Snqq4E7u65/OOBi6vqwaq6BVgLHNoea6vq5qr6AXBx6ytJmiN9z3G8Crgkyfo2vjfwa1u4zlcmOQlYA7y6qu4BlgJXjfRZ19oAbt+k/bDJFprkNOA0gP33338LS5MkTafvFwCvBp4GvBx4BfD0qrpmC9b3TuApwMHABuAtrT2TrXaK9slqPKeqVlTVij333HMLSpMk9dF3jwPgZ4FlbZ5nJqGqLhyysqq6Y2I4ybnAx9voOrpvpU/YF5jYu9lcuyRpDvQKjiTvpdtTuBZ4uDUXMCg4kuxdVRva6AuAiSuuVgHvT/JWYB9gOfBFuj2O5UmeBHyT7gT6fxmyTknSzOq7x7ECOLCqJj1MNJkkHwCOAPZIsg44CzgiycF0oXMr8NsAVXVjkg8BXwYeAk4f+c7IK4HLgG2B86rqxr41SJJmXt/guAH4CbrzEr1U1YmTNL9niv5vBN44SfulwKV91ytJGq++wbEH8OUkXwQenGisqueNpSpJ0rzVNzhWjrMISdLC0Ss4quqzSQ4AllfVp5PsSHfOQZK0yPS9rfrLgL8G3t2algIfGVdRkqT5q+8tR04HngXcBz/6Uae9xlWUJGn+6hscD7Z7RQGQZAmb+Qa3JOmxrW9wfDbJ64Ad2m+NXwJ8bHxlSZLmq77BcQawEbie7kt7l9L9/rgkaZHpe1XVD+l+Ovbc8ZYjSZrv+t6r6hYmOadRVU+e8YokSfPakHtVTdgeOAHYfebLkSTNd31/j+PbI49vVtXbgF8Zc22SpHmo76GqQ0ZGt6HbA9llLBVJkua1voeq3jIy/BDdLdFfNOPVSJLmvb5XVf3yuAuRJC0MfQ9V/cFU06vqrTNTjiRpvhtyVdXP0v3EK8BzgSuB28dRlCRp/hryQ06HVNX9AElWApdU1W+NqzBJ0vzU95Yj+wM/GBn/AbBsxquRJM17ffc43gt8McmH6b5B/gLgwrFVJUmat/peVfXGJJ8EfqE1nVJV/zS+siRJ81XfQ1UAOwL3VdVfAOuSPGlMNUmS5rG+Px17FvAa4LWtaTvgonEVJUmav/rucbwAeB7wPYCqWo+3HJGkRalvcPygqop2a/UkO42vJEnSfNY3OD6U5N3ArkleBnwaf9RJkhalvldVvbn91vh9wE8Cf1xVq8damSRpXpo2OJJsC1xWVc8GDAtJWuSmPVRVVQ8DDyR5/CzUI0ma5/p+c/xfgeuTrKZdWQVQVb87lqokSfNW3+D4RHtIkha5KYMjyf5VdVtVXTBbBUmS5rfpznF8ZGIgyd8MWXCS85LcmeSGkbbdk6xO8rX2726tPUnenmRtkutGf+M8ycmt/9eSnDykBknSzJsuODIy/OSByz4fOHaTtjOAy6tqOXB5Gwd4DrC8PU4D3gld0ABnAYcBhwJnTYSNJGluTBcctZnhaVXVlcDdmzQfD0wc9roAeP5I+4XVuYrui4Z7A8cAq6vq7qq6h+5y4E3DSJI0i6Y7Of7TSe6j2/PYoQ3Txquqfnzg+p5YVRvoZt6QZK/WvpRH/gztuta2ufZHSXIa3d4K+++//8CyJEl9TRkcVbXtLNWRSdpqivZHN1adA5wDsGLFikF7R5Kk/ob8HsdMuKMdgqL9e2drXwfsN9JvX2D9FO2SpDky28GxCpi4Mupk4KMj7Se1q6sOB+5th7QuA45Osls7KX50a5MkzZG+XwAcLMkHgCOAPZKso7s66k10d9o9FbgNOKF1vxQ4DlgLPACcAlBVdyd5A3B16/f6qtr0hLskaRaNLTiq6sTNTDpykr4FnL6Z5ZwHnDeDpUmStsJsH6qSJC1wBockaRCDQ5I0iMEhSRrE4JAkDWJwSJIGMTgkSYMYHJKkQQwOSdIgBockaRCDQ5I0iMEhSRrE4JAkDWJwSJIGMTgkSYMYHJKkQQwOSdIgBockaRCDQ5I0iMEhSRrE4JAkDWJwSJIGMTgkSYMYHJKkQQwOSdIgBockaRCDQ5I0iMEhSRrE4JAkDWJwSJIGMTgkSYMYHJKkQeYkOJLcmuT6JNcmWdPadk+yOsnX2r+7tfYkeXuStUmuS3LIXNQsSerM5R7HL1fVwVW1oo2fAVxeVcuBy9s4wHOA5e1xGvDOWa9UkvQj8+lQ1fHABW34AuD5I+0XVucqYNcke89FgZKkuQuOAv4uyTVJTmttT6yqDQDt371a+1Lg9pF517W2R0hyWpI1SdZs3LhxjKVL0uK2ZI7W+6yqWp9kL2B1kq9M0TeTtNWjGqrOAc4BWLFixaOmS5JmxpzscVTV+vbvncCHgUOBOyYOQbV/72zd1wH7jcy+L7B+9qqVJI2a9eBIslOSXSaGgaOBG4BVwMmt28nAR9vwKuCkdnXV4cC9E4e0JEmzby4OVT0R+HCSifW/v6o+leRq4ENJTgVuA05o/S8FjgPWAg8Ap8x+yZKkCbMeHFV1M/DTk7R/GzhykvYCTp+F0iRJPcyny3ElSQuAwSFJGsTgkCQNYnBIkgYxOCRJgxgckqRBDA5J0iAGhyRpEINDkjSIwSFJGsTgkCQNYnBIkgYxOCRJgxgckqRBDA5J0iAGhyRpEINDkjSIwSFJGsTgkCQNYnBIkgYxOCRJgxgckqRBDA5J0iAGhyRpEINDkjSIwSFJGsTgkCQNYnBIkgYxOCRJgxgckqRBDA5J0iAGhyRpkAUTHEmOTfLVJGuTnDHX9UjSYrUggiPJtsA7gOcABwInJjlwbquSpMVpQQQHcCiwtqpurqofABcDx89xTZK0KC2Z6wJ6WgrcPjK+DjhstEOS04DT2uh3k3x1K9a3B3DXVsy/RfLns73GR5iTbZ5Di217wW1eFPLnW7XNB/TptFCCI5O01SNGqs4BzpmRlSVrqmrFTCxroVhs27zYthfc5sViNrZ5oRyqWgfsNzK+L7B+jmqRpEVtoQTH1cDyJE9K8mPAi4FVc1yTJC1KC+JQVVU9lOSVwGXAtsB5VXXjGFc5I4e8FpjFts2LbXvBbV4sxr7Nqarpe0mS1CyUQ1WSpHnC4JAkDbJog2O6W5gkeVySD7bpX0iybParnFk9tvkPknw5yXVJLk/S65ru+azvrWqSvDBJJVnwl2722eYkL2p/6xuTvH+2a5xpPV7b+yf5TJJ/aq/v4+aizpmS5Lwkdya5YTPTk+Tt7fm4LskhM1pAVS26B90J9q8DTwZ+DPhn4MBN+rwCeFcbfjHwwbmuexa2+ZeBHdvwyxfDNrd+uwBXAlcBK+a67ln4Oy8H/gnYrY3vNdd1z8I2nwO8vA0fCNw613Vv5Tb/InAIcMNmph8HfJLuO3CHA1+YyfUv1j2OPrcwOR64oA3/NXBkksm+iLhQTLvNVfWZqnqgjV5F932ZhazvrWreAPxP4F9ns7gx6bPNLwPeUVX3AFTVnbNc40zrs80F/HgbfjwL/HtgVXUlcPcUXY4HLqzOVcCuSfaeqfUv1uCY7BYmSzfXp6oeAu4FnjAr1Y1Hn20edSrdJ5aFbNptTvJMYL+q+vhsFjZGff7OTwWemuQfk1yV5NhZq248+mzzSuA3kqwDLgV+Z3ZKmzND/78PsiC+xzEG097CpGefhaT39iT5DWAF8EtjrWj8ptzmJNsAZwMvna2CZkGfv/MSusNVR9DtVf5DkmdU1XfGXNu49NnmE4Hzq+otSX4OeG/b5h+Ov7w5Mdb3r8W6x9HnFiY/6pNkCd3u7VS7hvNdr9u2JHk28EfA86rqwVmqbVym2+ZdgGcAVyS5le5Y8KoFfoK872v7o1X1b1V1C/BVuiBZqPps86nAhwCq6v8B29PdAPGxaqy3aVqswdHnFiargJPb8AuBv6921mmBmnab22Gbd9OFxkI/7g3TbHNV3VtVe1TVsqpaRnde53lVtWZuyp0RfV7bH6G7EIIke9Adurp5VqucWX22+TbgSIAkT6cLjo2zWuXsWgWc1K6uOhy4t6o2zNTCF+WhqtrMLUySvB5YU1WrgPfQ7c6updvTePHcVbz1em7z/wJ2Bi5p1wHcVlXPm7Oit1LPbX5M6bnNlwFHJ/ky8DDwh1X17bmreuv03OZXA+cm+X26QzYvXcgfBJN8gO5Q4x7tvM1ZwHYAVfUuuvM4xwFrgQeAU2Z0/Qv4uZMkzYHFeqhKkrSFDA5J0iAGhyRpEINDkjSIwSFJGsTgkCQNYnBIkgb5/24X75p2t7y4AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LOGISTIC REGRESSION\n",
      "Airlines = {'flydubai', 'kuwait airways', 'Saudi Arabian', 'turkish airlines', 'Qatarairways', 'Royal Jordanian Airlines', 'oman air', 'emirates', 'etihad airways', 'gulf air'} ; Best Cross validation Accuracy of the model is 0.851212 ; F1-Score is 0.851201\n",
      "----------------------------------------------------------------------------------------------\n",
      "\n",
      "NAIVE BAYES\n",
      "Airlines = {'flydubai', 'kuwait airways', 'Saudi Arabian', 'turkish airlines', 'Qatarairways', 'Royal Jordanian Airlines', 'oman air', 'emirates', 'etihad airways', 'gulf air'} ; Best Cross validation Accuracy of the model is 0.850376 ; F1-Score is 0.850103\n",
      "----------------------------------------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "df['Recommended'].plot.hist()\n",
    "plt.title(\"Recommended plot for all Airlines\")\n",
    "plt.show()\n",
    "CreateModelLR(df)\n",
    "CreateModelNB(df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing the percentage of training data while reserving 20% for test\n",
    "There are two stark observations that can be made from the graph above:\n",
    "1. We can see that the perfomance of both the models improves with the increase in the percentage of the training data. For each of the models, 80% training and 20% test gives the best performance\n",
    "2. It can be notices that overall, logistic regression performs better on this data and gives a higher accuracy at all percentages of training data. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEKCAYAAAAFJbKyAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzs3XlYlFX7wPHvAVHcFXdFxTU3FhXcbXO31NTcSq1Mzbc0tdXKfM23X1nW69KiWfpqaoIt2mbuWporLpk7oKC4ogiCiCxzfn88A43IMgMMMOP9uS4umZlnnueGiJvnnHPfR2mtEUIIIazlUtgBCCGEcCySOIQQQthEEocQQgibSOIQQghhE0kcQgghbCKJQwghhE0kcQghhLCJJA4hhBA2kcQhhBDCJsUKO4D8UrlyZe3l5VXYYQghhEPZv3//Va11FVve4zSJw8vLi+Dg4MIOQwghHIpSKsLW98hQlRBCCJtI4hBCCGETSRxCCCFsIolDCCGETSRxCCGEsIkkDiGEEDaRxCGEEMImkjiEEEXS+qOXCLkcV9hhiExI4hBCFDn7I64zbvl+3lz9d2GHIjIhiUMIUaQkpZh444fDAOwLv86JSzcKOSKRkSQOIUSR8sXvYZy6HM+sx30pXsyF5btt7ogh7EwShxCiyAiLiueTLaE84l2Dx1t78qhPDVYfOE/87ZTCDk1YsGviUEr1VEqdVEqFKqWmZPJ6HaXUVqXUQaXUYaVUb/PzTyqlDll8mJRSfvaMVQhRuEwmzRs//I27mwv/7tsMgBHt6nIzKZXVB88XcnTCkt0Sh1LKFfgM6AU0A4YppZplOGwqsEpr3RIYCnwOoLVeobX201r7ASOAcK31IXvFKoQofEHB59h7Jpo3ezelall3APxqV6B5zXKs2B2B1rqQIxRp7HnH0QYI1Vqf1lonAYFAvwzHaKCc+fPywIVMzjMMWGm3KIUQhe7KjUTeW3uctvU8GBJQO/15pRQj2tXlxKU4giOuF2KEwpI9E0ct4JzF40jzc5amA8OVUpHAWmBCJucZgiQOIZza9J+PcjvFxPsDvFFK3fFaX7+alHUvJpPkRYg9E4fK5LmM95rDgCVaa0+gN7BMKZUek1KqLZCgtT6S6QWUGquUClZKBUdFReVX3EKIArTx2GXW/n2JFx9uSP0qZe56vVTxYgxs5clvf1/iavztQohQZGTPxBEJ1LZ47MndQ1HPAqsAtNa7AHegssXrQ8nmbkNrvVBr7a+19q9SxaadD4UQRUBcYjJvrznCfdXKMvb+BlkeN7xdHZJSTawKPpflMaLg2DNx7AMaKaXqKaWKYySBnzIccxboAqCUaoqROKLMj12AQRhzI0IIJzRr/UkuxyUyc6A3xYtl/euoYdWytKvvwTd7zpJqkknywma3xKG1TgHGA+uB4xirp44qpWYopfqaD3sZGKOU+gvjzuJp/c/SifuBSK31aXvFKIQoPPsjrrNsdwRPtfeiZZ2KOR4/op0Xkddv8fupKwUQnchOMXueXGu9FmPS2/K5aRafHwM6ZvHebUA7e8YnhCgcaW1FapRz55Ue91n1nu7Nq1GlbAmW7z7Lw02q2TlCkR2pHBdCFLi0tiL/eawFZUpY9/erm6sLwwJqs/XkFc5FJ9g5QpEdSRxCiAKV3lbEpwZdmtp25zC0TR0U8M3es/YJTlhFEocQosDc0VakT8ZGEjmrWaEkXZpWY9W+c9xOSbVDhMIakjiEEAUms7YithrRri7Xbiax7silfI5OWEsShxCiQGTVVsRWnRpWpm6lUlJJXogkcQhhI5NJ88epKHaGXeVCzC1MUldglezaitjCxUUxvG3de2qTp8ORMVyJSyzsMNLZdTmuEM7o062h/HfjqfTHJYq5ULdSKbwqlaZe5dLUrVQar8rG4+rl3HFxyf0vSWeR1lbkle6NM20rYqvHW3sya8NJlu+O4N3HvPMhwqIr9EocAz7fScXSxVn0lD8+nhUKOyRJHELY4vdTUczedIq+vjUZElCbM1dvEnHtJmeuJnDm6k22nYoiKcWUfry7mwt1PUpTt1KpO5JKvcqlqVb23kgq1rYVsUXF0sXp41OT1QfOM6VXU6uX9DoarTXv/HyMksVdKVHMhcFf7GLOkJb0bFG9UONyzu+2EHYQeT2BiYEHua9aWT4Y6EPJ4q50bFj5jmNSTZqLsbeIuJZwR1I5ffUm205GkZSadVLxqmx83rJ2RUoWdy3oL89uPjK3FZk/vFW2bUVsNbxdHb4/EMnqg+cZ0a5uvp23KNl47DLbQ64y7dFm9PGtyZivg/nXiv282aspozvXy9OQX15I4hDCConJqTy/4gCpqZr5w1tn+Yvd1UXhWbEUnhVL5Tqp1PYoyZwhLWldN+c2HEXd/ojrfG1DWxFbWG7yNLxtnUL7JWovicmpvPvrcRpVLcOI9nVxc3UhcGw7Xlp1iP9be5wz124yo29zirkW/FS1JA4hrPDOz8c4HBnLwhGtqVe5dK7OYU1SOXrhBu/+eozBX+zixYcb8cJDDQrlF0N+yE1bEVukbfI05Ye/CY64ToCXR75fozAt2nGGs9EJLH+2LW7mnwF3N1c+HdaKWZVOMn9bGJHXb/HZEy0p6+5WoLE55k+kEAVoVfA5Vu49y78ebED35vYZW05LKj2aV2fti53p61uT2ZtOMXThbodtr5GbtiK2ctZNni7FJvLZ1lC6N6tGp0Z3/pHh4qJ4vWcTPhjozc7Qqzw+fxfnY24VaHySOITIxpHzsby95ggdGlTi5W6NC+SaZd3dmD3Ej7lD/Th5KY7ec7fz46HzBXLt/JKXtiK2cNZNnmb+dpwUk2bqI1lX1w8JqMOSZ9pwIfYWj332J4cjYwosPkkcQmQhNiGZf63YT8VSxZk3rGWBDxn186vF2omdaVy9LBMDDzE56BBxickFGkNu5LWtiK2cbZOn4PBo1hy6wNjO9alTqVS2x3ZqVJkf/tUhfcVVQVXTS+IQIhMmk2ZS0EEuxSby+fBWVC5TolDiqO1RiqCx7ZjUtRE/HjpP73nb2R9xvVBisVZaW5G3Hsl9WxFbONMmT6kmzfSfj1K9nDvPP2Td0uVG1cqy+vmONKlejn+t2M+Xf5zmn22N7EMShxCZ+HRrKFtPRjHt0Wa0yufVQLYq5urCpK6N+XZcewAGf7GLuZtCSLFY2ltUpLUVaVffg8H+uW8rYitn2eTp2+BzHDl/gzd6N6FUcevnhaqULUHg2Hb0blGD/1t7nLfWHLHrz4ckDiEySCvy69+yFsOLUH1A67oeRX7i/J+2Ij4FujzWcpMnRxV7K5kP158kwKsifX1r2vx+dzdXPhnWkn892IBv9pxl1NJguw1tSuIQwsK56H+K/N7rn7eeSvZQlCfO09qKTOzSKNdLlnPLGTZ5mrsphOsJSfy7T/Nc/9xltuIq8nr+fz8kcQhhZm2RX1Fg88T56d9h0ztwLcwu8aS1FWlSvSxj769vl2vkxJE3eQq5HMfXu8IZGlCHFrXK5/l8QwLqsHRU2oqrnfx1LpMVV4k3YM8XuTq/JA4hzN75+Sh/n4/l48G+Bf4Xc25YPXEevBiW9Ycd/4VPWsGKQRC6CUz5Nwae1lbk/QHe6cVqBa1mhZJ0dcBNnrTWzPjF6Ef1Svf8W/LdsaGx4srdzYUhCy1WXF0NhbWvwX+bwW+v5erckjiEIK3I75xdi/zsIduJc5MJ1r8Fv0yGhl1gwgF48A24cAiWD4TPAmDPQrgdl6cY7NlWxFbDHXCTp7R+VC91a0ylfF69l7biqmm1MgSuXMTZT3rDp62NPyaa9IbRW3J1XmXvZVsFxd/fXwcHBxd2GMIBHTkfy8D5O/H3qsjSZ9o4bIuPuMRkpv14lNUHz9OhTkm+KruQUmG/QZux0ON9cDWv0klJgmM/wp4FcD4YipeFlsOhzRioZN0S0NspqZyLvkX41Zt8sO4EN2+nsOGlB/KvQjz+CoTvgJp+4GH90JfJpHno421ULVuCb8d1yJ9Y7CgxOZXus/+gRDEX1k7snP93a4k34K+VmPZ8gUt0GFd0BQ5XH8gDT7yKW/kaACil9mut/W05rV17VSmlegJzAVfgK631zAyv1wGWAhXMx0zRWq81v+YDfAGUA0xAgNa66OxkIpxCWpGfR+nizBta8EV++Slt4rxHXaj12yjcL5/mb5838O495c4DixUHn0HGR+R+2PsF7PsK9syHRt2h7XNQ/2Fum3R6cgi/ZnykNWi8EHOLtJIJN1fFwpH+eUsaplSIDIbQjRCyES4eMp4vUQ4GL4UGD1t1mrRNnv5v7XFOXLpBk+rlch9TAcisH1W+uBoKexfCoW8gKQ4XzwBMD0xh6fmmfPbHWTp/d5bPnqxMuVz2uLLbHYdSyhU4BXQDIoF9wDCt9TGLYxYCB7XW85VSzYC1WmsvpVQx4AAwQmv9l1KqEhCjtc5y4FLuOIStTCbNs0v3sSP0Kquea1/owyz54vIx+GYwpptX+aDMa3xx6T76t6zFjH7NM22El3bncOFcOKWPLKPxuW8pm3KNs6omi5K68V3q/dykJADl3ItZ7ClSGq9KpfCqXJr6lUtToVRx22ONv2LMtYRshLAtkBgDygU820CjruAZYAy1XTkOj3wM/s9YddrrN5No+/5mBvt7FulNni7FJvLwx9vo3KgyX4yw6Q/+zJlMELbZmPAO3QgubtBiALR5Djxbpx8WtO8sb60+QoMqZVj0tD+1PUoXqTuONkCo1vo0gFIqEOgHHLM4RmPcUQCUBy6YP+8OHNZa/wWgtb5mxzjFPeqTLUaR33/6NXeOpBG6CVY9DSXK4DJqHa9W86Hk1lDmbQ4hOCKaSV0acz0hKcs7B7gfD/f7ebLMQQam/MI7eilTS37H9caDKdFhHOVq3Ze35clZ3VWUrgpNHoGGXaHBQ1DS4r/FqHXw7TPwyySIPg1d3wGX7P8yd5RNnqzpR2UV83AUe76A6DAoUw0efBNaPw1l7+4TNiSgDp4VSzFu+X4e+2xnri5pzzuOx4GeWuvR5scjgLZa6/EWx9QANgAVgdJAV631fqXUJKA1UBWoAgRqrT/M7npyxyFsse3kFZ5Zso/H/Grx38G+Ra5ew2bBi+HXV6BqM3giCMrXSn9pf0Q0k4IOcS7a6KCa1Z1DvUqlqVDK7Z/vRdow1pEfwJR8xzBWTr+80+V0V9GwG1T3yf58qSmw7nVjOK1pH+i/EIpn38Pp4Nnr9P98J/95rEWR3OQpODyaxxfsYvxDDXPfcj59OGoFJMUbd2htnoNm/YzhyByEXI7jmSX7+HNKF5vvOOyZOAYBPTIkjjZa6wkWx7xkjuFjpVR7YBHQAngJeAEIABKAzcBUrfXmDNcYC4wFqFOnTuuICOdqrSzs41x0An0+3UH1cu6sfr5jka7XyJHJBBvfhl2fGr/YH18MJcredVhCUgphV27iWbHkncnBGnGXYf//jOQUfxkqNTR+QfkNu/ta2d1VNOqW+V2FNbSG3fNh/ZtQsyUMC8z0r+l/Dtf0+XQHKama3yZ2LlJ/GKSaNP0+28HVuCS2vPKATa1F/hmOWmAk5CyGo6wVFXebquXci1TiaA9M11r3MD9+A0Br/b7FMUcx7krOmR+fBtoBD5uff9r8/NtAotZ6VlbXkzsOYY3E5FQGLdhF+NWb/DShk0PUa2QpKQF+GAMnfrl75ZQ9ZLUay3eIMQ+Rl7sKa51YC98/C6UqwROroFrWwzyBe88y5Ye/+XZc+yK1yVNaXHOH+tHPr1bObwBjOOrQN8YdRtpwlP+zWQ5H2SI3q6rsmTiKYUyOdwHOY0yOP6G1PmpxzG9AkNZ6iVKqKcadRS2MVVabgU5AErAOmK21/jWr60niENZ444fDrNx7joUjWjtUvcZd4i7DyiFGTUbPmdBuXMFeP+MwFuT9rsJaFw7CN0MhOSHbFVcJSSm0fW8zDzepytyhLe0Ti41ibyXz0EfbaFClNKuea5/znVBqMuxbBNveNxKyjcNR1ihSy3G11ilKqfHAeoyltou11keVUjOAYK31T8DLwJdKqckYE+VPayOTXVdK/Rcj2WiM1VZZJg0hrLFqn1Hk97yDFfndxbxyioRoGLYS7utV8DF4tgbPhdDtP8aQSbXm+XdXkZOaLWHMZvhmCCx/PMsVV2mbPK3YE8HbjzYrtNb4lv7pR9Um56RxaoMxNHctBOo/CA9Py9VwlD1IAaC4Jxw5H8uA+TsJ8KrI16Pa4upSdMa8bWKxcoongqCGb2FHVHhuxxkrrkI3QocJ0HXGXYkr9EocXf/7B6/1vI/nH2xYSIEaQi7H0Wvudgb51+b9AdksE75yAja8Zfy39mgAPd6Dxj3ATvM0ubnjcNxqJyGsFJOQxLjl+6lkLvJz2KSxbxGsGAwVvWD05ns7aYAxMT8sEAJGw85P4NuRxryPhYZVy9K+fqVC3+TJqn5UCdGw9lWY3wHO7TMSxvO74b6edksauSWJQzg1k0kzOegQl28k8vmTrfK9F1CBSOs59etLxvzBqN/uWG57T3MtBr0/MhYGHP8FljxizP9YGN6ubqFv8pRtP6rUZNi9AOa1NJYc+z8DLx6E9i/k2zxGfpPEIZxaWpHftEebOWaRX1ICrBphLLdtMxaGfpPpctt7mlLQ/nnjexN1Ar7qYswDmRX2Jk+Jyam8++txGlUtc/fGYKc2wOftjTqVmn4w7k9jzqZ0pUKJ1VqSOIRTMpk0K/ZEMGdz0dvJz2pxl2BJbzjxK/T8AHrPsu9yW0fXpDc8s9b4C35xDwg1yr4Ke5OntH5U/+7T/J9+VFdOGB2KvxkEaBgWBCPWZLu8uCiRxCGczt4z0fT9bAdvrT5CgJdHkdzJL0eXj8KXXSDqlLFyqqCX2zqqtBVXFeoY+44E/w8ovE2eLsbe4tMtofRoXo1OjSrfOY8Ruc8YYvvXriI5j5Ed+fNFOI1z0QnM/O0Ev/59kerl3JkzxI++vjVxcbTJcMuVU6N+k0lwW5X3zNDjKoyaXWfQtWk1gvadY1LXRpQoVjDdAmb+doJUrZnas5Exj7Htfbh9A/xHGf2kiviQVFYkcQiHF387hfnbQvly+xlcFEzq2oix99e3rZVDUbF/qbHxUiY9p4QN0lZcrXvdWHF1PZyR/u+x4dhl1h25ZH3Fdh4Eh0fz46ELfOx3mdqBXcz1GA8Zq6UcZEgqKw74f5YQBpNJ8/2BSD5cf5KouNs85leT13s1oUb5koUdWu6EbYGfJxq79Q1aIpPgeZW24sqjAax/k46x52lVcQLLd0fYPXGkmjSLVv/GypJf0v7EQaO/17Agu9ZjFCRJHMIh7QuPZsbPx/j7fCx+tSvwxYjWtHLEVVNpYs7Bd89C1aYw+Gso7sA9tIqStBVXFb1Q3z/LUpc3GBgxmROXWthvk6eEaMKC3uSTmCBMxcvAw+8btSZFdGltbkjiEA7lXHQCM9ed4NfDDj6PYSnlNqwaCaYUGLxMkoY9mFdclV4xhO+LT+eXNVFU8m+BR+niuObnHcC1UEzbP6ZB4g02lu5NjxfmQunK+Xf+IkISh3AIN2+n8LmzzGNktG4KXDgAQ5ZD5cJti+HUarbEZewW4uf3Zdilj+AX+1zmTNk2PH9jIB+PGYYqXd4+FylkTvB/nXBmTjePkdGhb4x9LjpONDYpEvZV3pMqk//kr8P7uBiTwIXYW1yIucWlmEQuxCZyO8WUfqibiwvVy5egZoWS1ChfkpoV3KlRwZ2a5UtSpWyJTO9Uwm9oun99gcH+dWhRyzmTBkjiEEWY081jZHTxsLGCyquz0flUFIhiJUriG3A/GRc5m0yaK3G3OXP1JhHXbnLm2k3Cr95k57UEws/dJDHZhLGvXALFXV2o7VHyjp0U61UqzfwdoZQqXizrflROQhKHKHKcch4jo1vXjVYiJT3g8f9JRXgR4OKiqF7enerl3Wnf4M76iqySSsS1BHaEXjUnFcO/+zRzzJ5oNpCfVlFkOPU8hiWTCVaPg9jzRouMMlUKOyKRA2uTSkxCkmPv9WIlJ/s/Ujgip5/HyGjHx3BqHfSaBbXbFHY0Io8sk8q9QhKHKDSJyan8eOg8//sznBOX4pxzHiOjsC2w5f/AexC0GVPY0QiRK5I4RIE7H3OLZbsiCNx3lpiEZJpUL8vcoX708XGyeYyMLIv8+sx1igpicW+SxCEKhNaaPWeiWfJnOBuOXQKge7PqPN3Ri7b1PByve62tpMhPOBFJHMKubiUZw1FLdhrDURVKuTH2/gYMb1cHz4qlCju8gvPb61LkJ5yGJA5hF5kNR80c4E0/v1qULF4wLa2LjEPfwP7/QcdJUuQnnIIkDpFv7vnhqMzcUeT3dmFHI0S+kMQh8qzIDkdFnYLQjdBqZOG0KJciP+Gk7PqTrJTqCcwFXIGvtNYzM7xeB1gKVDAfM0VrvVYp5QUcB06aD92ttZa9M4uYIj0clRBt7Okcexb+nAtdpoHvE+BSQLslS5GfcGJ2SxxKKVfgM6AbEAnsU0r9pLU+ZnHYVGCV1nq+UqoZsBbwMr8WprX2s1d8InccYjjKlAo/jIH4S9D3EzjwNfz4AuxdCD1nQt0O9o9huxT5CedlzzuONkCo1vo0gFIqEOgHWCYODaTtplIeuGDHeEQepKSa+OHAeRb/eaZoDUdl5vcPjX27H51tDFO1HAFHvoeN0+B/vaDZY9DtHajoZZ/rh26GrVLkJ5yXPRNHLeCcxeNIoG2GY6YDG5RSE4DSQFeL1+oppQ4CN4CpWuvtdoxVZOP3U1H855djhF6JL1rDUZkJ2Qi/f2AMS7V+xnhOKfB+HO7rbew//eccOPkbtH8BOr+Uv/MfMWfh+9FS5Cecmj0TR2b/x+gMj4cBS7TWHyul2gPLlFItgItAHa31NaVUa2CNUqq51vrGHRdQaiwwFqBOnTr5/xXc40KvxPN/vx5j68ko6lYqxRcjWtO9WbWiMRyVmevhxi/tai3gkY/v/qVdvBQ8+Dq0HA6b34Ed/4VDK/Jv/iPlNqx6yijyG7JcivyE07LnTGEkUNvisSd3D0U9C6wC0FrvAtyBylrr21rra+bn9wNhwF0N7rXWC7XW/lpr/ypVZPIxv8QkJDH9p6P0nPMHweHXebN3EzZMvp8ezasX3aSRfMuozNYahnxtJImslK8FAxbC6M1QoY4x//HlgxCxM28xpBX5PTYfKjXI27mEKMLsecexD2iklKoHnAeGAk9kOOYs0AVYopRqipE4opRSVYBorXWqUqo+0Ag4bcdYBZCcauKbPWeZvekUN24lM7RNHV7q1pjKjrC3wNpX4OJfMCwIPOpb9x5Pf3h2Y/7Mf9xR5PeozeEL4Ujslji01ilKqfHAeoyltou11keVUjOAYK31T8DLwJdKqckYw1hPa621Uup+YIZSKgVIBcZpraPtFau4cx6jff1KTOvTjKY1yuX8xqJg/1I4uBw6vwL39bTtvfkx/yFFfuIeo7TOOO3gmPz9/XVwcHBhh+FwMs5jvNW7Kd2K8jxGRhcOwqIexhLb4d+DSx4n7GPPG/Mfh4OgTLWc5z9uXYcvHoDUZHjuD6nXEA5HKbVfa+1v03skcdybYhKSmLMphOW7Iyjp5sqELg15qoMXJYoVwZVSWUmINn5po2Hs71C6Uo5vsVpkMKybApH7oIZv5vUfJhOsHGrssfHMWqnXEA4pN4lDeiDcYxx6HsOSZZHfqHX5mzTAuvmP7R9DyHro/ZEkDXFPyTFxmOcpVmitrxdAPMKOLOcxOjSoxNuPOtA8RkaWRX61WtvnGtnNf9RsaS7yGwwBo+1zfSGKKGvuOKpjtAs5ACwG1mtnGd+6R2Scx1g4orVjzWNkdGrD3UV+9pRZ/QdA1WbQZ44U+Yl7jlVzHMr4DdMdeAbwx6i9WKS1DrNveNaTOY67ZZzHeLFLI0Z2qOtY8xgZXQ835jXK14ZnN2Rfr2EvkcHG0tvOL1u/9FeIIspucxzmJbKXgEtAClAR+E4ptVFr/ZrtoQp7cpp5jIySb0HQCOuK/OzJ09/4EOIeZc0cx4vAU8BV4CvgVa11slLKBQgBJHEUIScu3WD8Nwfzfx4j/grs/hzuewRqB+T9fLmx9hW4dNi2Ij8hRL6z5o6jMjBAax1h+aTW2qSUkhLZIiQhKYXnlx8g7nZK/s5jnNoAPz4PN6Ngx2yj62vX6VDeM+/ntlZakd/9r9pe5CeEyFfW9KpaC6RXbSulyiql2gJorY/bKzBhu/fWHuf01ZvMHeJH9/zoK5V8C9a+Bt8MgtJVjd5OnV+BYz/BJ/6w9X1Iupk/wWfnwkFY+yo0eBgefMP+1xNCZMuaxDEfiLd4fNP8nChCtp64wvLdZxndqR4dGlbO+wkvH4UvH4a9X0Dbf8GYLca4fpe3YUIw3NcLfp9pJJDDq4xiOHtIiIagkVCmKgz4Ku+V4UKIPLMmcSjL5bdaaxNSOFikXIu/zavfHaZJ9bK80uO+vJ1Ma9i9ABY+BDevwpPfQ6+Z4Ob+zzEV6sCg/8Ez64xf6D+MgUXd4Ny+vF07I1Oq0SY9/hIMXpr/RX5CiFyxJnGcVkq9qJRyM39MRDrVFhlaa6b88Dc3biUzZ6gf7m55+Is8/gqsGATrXof6D8K/dkKjrlkfX7c9jNlqtBGPjYRFXY1f9LGRuY/B0u8fQNhm6PWB/Yr8hBA2syZxjAM6YLRGT9vFb6w9gxLWWxV8jo3HLvNqj/toUj0Pq6dObYD5HSB8u9FC44kg6xr2ubiA3xMwYb8xcX385/yZ/yjoIj8hhNWkyaEDi7h2k15zt+PrWYEVo9vi4pKLyfDkW7Dx38ZcRtXm8PgiY9vT3Io5a5zv6A9QtqbR26nF47btrpdW5FehttEvyq1k7uMRQmTLLgWASil3jJ36mmNstASA1nqUzRGKfJOSamJy0CFcXRQfD/bNXdK4fNQYWrpyzJgA7zr9zrmM3Eib/2j7nNFd9ocxsOcLo7usNfUfaUV+aBi8TJKGEEWQNX8GLsPoV9UD+B1jC9g4ewYlcvb5tjAOnI3h3cdaULOCjb9crZkAz6s67WD0FtvnP9KK/PovBI96+RePECLfWJM4Gmqt3wZuaq2XAo8A3vYNS2Tnr3MxzN0cQl/fmvRqGxXvAAAgAElEQVTzq2Xbm22dAM8LW+c/pMhPCIdgTeJINv8bo5RqAZQHvOwWkchWQlIKk4MOUbVsCf7Tr4Vtbz61Hj5vb/sEeF6VKAMPT4Xx+7Ku/zh/wLjbkCI/IYo8axLHQqVURWAq8BNwDPjArlGJLL239jhnrt3k48G+lC/lZt2bkm8ZldffDDa2Qx27DdqMKfh24GnzH6PWQ9lq/9R/hGyEVU8ZsUmRnxBFXraT4+ZGhjfMmzj9AUhnuUK05cRllu8+y5jO9ejQwMrqcHtMgOdV2vzH4UDY9A6seBxci9tnJz8hRL7LNnGYGxmOx9h/QxSia/G3ee27v62vDtfaWM20cRq4lzcmwO01l5EbafMfTfsaS4Er3ydFfkI4CGtah2xUSr0CBGH0qQJAax2d9VtEfrKsDl8+uk3OGzHFX4E1z0PoRmjUHfp9XjBzGblRooyxIZIQwmFYkzjS6jVesHhOY8WwlVKqJzAXcAW+0lrPzPB6HWApUMF8zBSt9doMrx8DpmutP7IiVqeUVh0+9ZGmd1eHp6ZATAREn4HoMLgWZhTf3Y4zJsADRsvWpkKIfJVj4tBa52oxvVLKFfgM6IbRqmSfUuonrfUxi8OmAqu01vOVUs0wWrh7Wbw+G/gtN9d3FhHXbvLuz3/Tv24io6qFwZ6NRnKIPm0kipizYEr55w3Fy0ANP+g9C6o1K7zAhRBOy5rK8ZGZPa+1/jqHt7YBQrXWp83nCQT6YdxBpJ8GSPsTujxwweK6j2E0UyyADR+KgIx3DtGnMV0Lxe3MMQ64XMbtcip8Yz62eBmjOK66DzR7DCo1AI8Gxq54ZarKHYYQwq6sGaqy7BPhDnQBDgA5JY5awDmLx2kNEi1NBzYopSYApYGuAEqp0sDrGHcrr1gRo+MJ22LUVaTdPcRE3HXncM2tJgeSatO46aM0buoryUEIUSRYM1Q1wfKxUqo8RhuSnGT2my1jR8VhwBKt9cdKqfbAMnOR4TvAbK11fHa72CmlxmLu1FunTh0rQioCtDa2X938DriVhkr1obo3NH/MSArm5PDX9eIMWLCLR7xr8OiwloUdtRBCpMvNhkwJQCMrjosEals89sRiKMrsWaAngNZ6l7mhYmWMO5PHlVIfYkycm5RSiVrrTy3frLVeCCwEoztuLr6WgpWaDL9MhoPLoMVAY7VTJjUVCUkpTF61g2q5qQ4XQgg7s2aO42f+uVNwAZphXV3HPqCRUqoexl4eQ4EnMhxzFmPoa4lSqinGUFiU1rqzxfWnA/EZk4bDuRUDq0bCmd+NXkwPvpllq/G06vAVo9taXx0uhBAFxJo7DstlsClAhNY6xy3etNYp5uLB9RhLbRdrrY8qpWYAwVrrn4CXgS+VUpMxktPT2lk2CLF0PRxWDDbmMh6bbxS+ZSFX1eFCCFGActzIyXzHcFFrnWh+XBKoprUOt3941iuyGzmd2wcrh4IpGYasgHqdszz0WvxteszZTuUyxflxfMecC/2EECKPcrORkzVNDr8FTBaPU83PiZwcXQ1LHzWqo0dvzjZpZNw7XJKGEKKosiZxFNNaJ6U9MH9e3H4hOQGtYft/4dunoYavkTQqZ7+eIK06/LWeedw7XAgh7MyaxBGllOqb9kAp1Q+4ar+QHFxqMvw0wVhu2+JxGPkTlM5+riL86k3e+fkYHRpUYlRH2fVOCFG0WTM5Pg5YoZRKW9UUCWRaTX7PuxUDq0bAmT/g/tfgoTdzLNRLSTUxedUhirkoPhqUy73DhRCiAFlTABgGtFNKlcGYTJf9xjNzx8qpBeA3zKq3fb4tjINnY5g3rKXte4cLIUQhyHGoSin1nlKqgtY6Xmsdp5SqqJR6tyCCcxjn9sGXXSD+MoxYbXXSSNs7vJ9fTfr61rRzkEIIkT+smePopbWOSXtg3g2wt/1CcjDpK6fKwuhN2a6cspS2d3i1siWYIdXhQggHYs0ch6tSqoTW+jak13GUsG9YDkBr2PFf2DwDareDod9Yve3pyUtxzFp/4p/q8JJSHS6EcBzWJI7lwGal1P/Mj5/B2Hzp3pWaDL9MgoPLjZVT/T7LcR/vVJNm0/HLLN0Zzs6wa5Qo5sKUnk2kOlwI4XCsmRz/UCl1GKPluQLWAXXtHViRZePKqdiEZIKCz/L1rggir9+iVoWSvN6zCUMDalOxtJTDCCEcj7XdcS9hVI8PBs4A39stoqLMhpVTJy/FsWRnOKsPRpKYbKJtPQ+mPtKUrk2rUczVmqklIYQomrJMHEqpxhgdbYcB14AgjOW4DxVQbEVLes+pFBi5Brw63XVI2nDUkj/D2XXaGI7q37IWT3XwomkNqQYXQjiH7O44TgDbgT5a61AAcxfbe8/R1bB6HJStAU9+e1f7kMyGo6b0asIQfxmOEkI4n+wSx0CMO46tSql1QCCZ7+rn3HbMhk3TM105JcNRQoh7UZaJQ2u9Glht3v/7MWAyUE0pNR9YrbXeUEAxFp4rJ4yk0by/Mafh5i7DUUKIe541q6puAisw+lV5AIOAKYDzJ45T64x/e7xHTLILQTvDWLZbhqOEEPc2m/Yc11pHA1+YP5xfyAYSKzfnnU3XWH3wLxKTTbSrL8NRQoh7m02J455yKwZ9djeLU/rww6VIGY4SQggzSRxZSDy5CXedyuGSbdn54sNUKiNdVoQQAqxrcnhPOrJtFdd1GZ4dOkiShhBCWJDEkYn1Ry7gdX0XF6t0JKB+lcIORwghihRJHBlcuZHIsu9XU1ndoHGngYUdjhBCFDmSOCxorXnt+8O0S92PVi4Ua9ytsEMSQogix66JQynVUyl1UikVqpSaksnrdZRSW5VSB5VSh5VSvc3Pt1FKHTJ//KWU6m/PONMs3x3BtpNRDK1wAuUZAKU8CuKyQgjhUOyWOJRSrsBnQC+gGTBMKdUsw2FTgVVa65YY7U0+Nz9/BPDXWvsBPYEvlFJ2XQEWFhXP/609Tt8GrlS+cRQadbfn5YQQwmHZ846jDRCqtT6ttU7C6HXVL8MxGkgrjCgPXADQWidorVPMz7ubj7Ob5FQTkwIPUdLNlXebXzSebNzDnpcUQgiHZc/EUQs4Z/E40vycpenAcKVUJLAWmJD2glKqrVLqKPA3MM4ikWBxzFilVLBSKjgqKirXgc7dFMLf52N5f4A35SK3QtmaUE32ARdCiMzYM3Fk1kk3453DMGCJ1toT6A0sU0q5AGit92itmwMBwBtKqbv2ZtVaL9Ra+2ut/atUyd2y2f0R0Xy+LZRBrT3p2bQyhG2FRt2y3dVPCCHuZfZMHJFAbYvHnpiHoiw8C6wC0FrvwhiWumMTbq31ceAmkO+3APG3U5gc9Be1Kpbk332bw9ldcPuGDFMJIUQ27Jk49gGNlFL1lFLFMSa/f8pwzFmgC4BSqilG4ogyv6eY+fm6wH1AeH4HOOPno0ReT2D2YD/KlCgGIRvAtTjUeyC/LyWEEE7DbiuVtNYpSqnxwHrAFVistT6qlJoBBGutfwJeBr407yyogae11lop1QmYopRKxtjr/Hmt9dX8jG/dkUusCo7khYca4O9lXnZ7agPU7QglyuTnpYQQwqnYdYmr1notxqS35XPTLD4/BnTM5H3LgGX2iuvKjUTe+OEw3rXKM7FLY+PJ6+Fw9ST4P2OvywohhFO45yrH06rDbyWnMnuIH8WLmb8FIRuNf6V+QwghsnXPJY606vA3ezelYVWLIalT68GjAVRqUHjBCSGEA7inEkfoFaM6/IHGVRjRru4/LyQlQPh2udsQQggr3DOJIynFxOQgozp81uM+KMs6jfDtkJIIjSVxCCFETu6ZHQDnbTaqwxcMb0XVchlqCU+tB7fSxooqIYQQ2bon7jjuqA5vUePOF7U26jfqPwjFZKc/IYTIidMnjruqwzOKOgGx52SYSgghrOT0Q1Vp1eGrnmtvVIdndGq98a9MjAshhFWc+o5j3ZGLrAqO5PkHG/5THZ5RyAao5g3lahZscEII4aCcNnEY1eF/G9XhXRtlftCtGDi7W4aphBDCBk6ZODJWh7u5ZvFlhm0BnQqNpBuuEEJYyykTR5bV4RmFbICSFcHTv+CCE0IIB+d0iSP0Sjzv/ppJdXhGJpPRn6phV3BxLbgAhRDCwTlV4kirDi9VPJPq8IwuHISEqzJMJYQQNnKq5bj/VIe3vrs6PKOQ9aBcoGGXgglOCCGchNPccSQkpVhUh1fP+Q2n1oNnAJTKYpmuEEKITDlN4jgXfQvPiqUyrw7PKO4yXDwkRX9CCJELTpM4klJNzB7im3l1eEahsmmTEELkltMkjnqVS9O6rpXDTqfWQ9maUN3bvkEJIYQTcprEYdWdBkBqMoRthUbdILtVV0IIITLlNInDamd3QVKcDFMJIUQu3XuJ49R6cC1u7L8hhBDCZnZNHEqpnkqpk0qpUKXUlExer6OU2qqUOqiUOqyU6m1+vptSar9S6m/zvw/nW1AhG42d/kpk04pECCFEluyWOJRSrsBnQC+gGTBMKdUsw2FTgVVa65bAUOBz8/NXgT5aa2/gKWBZvgR1PRyunpRhKiGEyAN73nG0AUK11qe11klAINAvwzEaKGf+vDxwAUBrfVBrfcH8/FHAXSmV931dT20w/m0sbUaEECK37NlypBZwzuJxJNA2wzHTgQ1KqQlAaaBrJucZCBzUWt/Oc0QhG8CjAVRqkOdTCSHEvcqedxyZrXXVGR4PA5ZorT2B3sAypVR6TEqp5sAHwHOZXkCpsUqpYKVUcFRUVPbRJCVA+HYZphJCiDyyZ+KIBGpbPPbEPBRl4VlgFYDWehfgDlQGUEp5AquBkVrrsMwuoLVeqLX211r7V6lSJftozvwBKYmy258QQuSRPRPHPqCRUqqeUqo4xuT3TxmOOQt0AVBKNcVIHFFKqQrAr8AbWus/8yWakA3gVtpYUSWEECLX7JY4tNYpwHhgPXAcY/XUUaXUDKVUX/NhLwNjlFJ/ASuBp7XW2vy+hsDbSqlD5o+qeQjGSBz1H4RieZ9jF0KIe5ld9+PQWq8F1mZ4bprF58eAu24BtNbvAu/mWyBXjkPsObj/lXw7pRBC3KucaiOnLIWYl+HKxLiwUnJyMpGRkSQmJhZ2KELkC3d3dzw9PXFzc8vzue6dxFHNG8rVLOxIhIOIjIykbNmyeHl5Zb8FsRAOQGvNtWvXiIyMpF69enk+n/P3qrp1Hc7ultVUwiaJiYlUqlRJkoZwCkopKlWqlG930M6fOMK2gk6FRlItLmwjSUM4k/z8eXb+xBGyAUpWBE//wo5ECJuUKZP3RpwXLlzg8ccfz/L1mJgYPv/8c6uPz+jpp5+mXr16+Pn54evry+bNm/MUb35bsGABX3/9db6db/bs2bi7uxMbG5tv53REzp04TCajG27DruDiWtjRCFHgatasyXfffZfl6xkTR07HZ2bWrFkcOnSIOXPmMG7cuFzHaiklJSVfzjNu3DhGjhyZL+cCWLlyJQEBAaxevTrfzpmZ1NRUu54/r5w7cVw4CAlXZZhKOI2IiAi6dOmCj48PXbp04ezZswCEhYXRrl07AgICmDZtWvrdSnh4OC1atADg6NGjtGnTBj8/P3x8fAgJCWHKlCmEhYXh5+fHq6++esfxqampvPLKK3h7e+Pj48Mnn3ySbWzt27fn/Pnz6Y/379/PAw88QOvWrenRowcXL14EYN++ffj4+NC+fXteffXV9OstWbKEQYMG0adPH7p3N+YkZ82aRUBAAD4+Pvz73/8G4ObNmzzyyCP4+vrSokULgoKCAJgyZQrNmjXDx8eHV14xlt5Pnz6djz76CIBDhw7Rrl07fHx86N+/P9evXwfgwQcf5PXXX6dNmzY0btyY7du3Z/r1hYWFER8fz7vvvsvKlSvTn8/q+7Rv3z46dOiAr68vbdq0IS4ujiVLljB+/Pj09z766KNs27YNMO4wp02bRtu2bdm1axczZswgICCAFi1aMHbsWIwSNwgNDaVr1674+vrSqlUrwsLCGDFiBD/++GP6eZ988kl++iljvXX+ce5VVSHrQblAwy6FHYlwYO/8fJRjF27k6zmb1SzHv/s0t/l948ePZ+TIkTz11FMsXryYF198kTVr1jBx4kQmTpzIsGHDWLBgQabvXbBgARMnTuTJJ58kKSmJ1NRUZs6cyZEjRzh06BBgJJo0Cxcu5MyZMxw8eJBixYoRHR2dbWzr1q3jscceA4zlzBMmTODHH3+kSpUqBAUF8dZbb7F48WKeeeYZFi5cSIcOHZgy5c5tenbt2sXhw4fx8PBgw4YNhISEsHfvXrTW9O3blz/++IOoqChq1qzJr7/+CkBsbCzR0dGsXr2aEydOoJQiJibmrvhGjhzJJ598wgMPPMC0adN45513mDNnDmDc4ezdu5e1a9fyzjvvsGnTprvev3LlSoYNG0bnzp05efIkV65coWrVqpl+n5KSkhgyZAhBQUEEBARw48YNSpYsme337+bNm7Ro0YIZM2YA0KxZM6ZNM8reRowYwS+//EKfPn148sknmTJlCv379ycxMRGTycTo0aOZPXs2/fr1IzY2lp07d7J06dJsr5cXzn3HcWo9eAZAKY/CjkSIfLFr1y6eeOIJwPhlsmPHjvTnBw0aBJD+ekbt27fnvffe44MPPiAiIiLHX2SbNm1i3LhxFCtm/H3p4ZH5/0evvvoq9evXZ/jw4bz55psAnDx5kiNHjtCtWzf8/Px49913iYyMJCYmhri4ODp06JBprN26dUu/zoYNG9iwYQMtW7akVatWnDhxgpCQELy9vdm0aROvv/4627dvp3z58pQrVw53d3dGjx7NDz/8QKlSpe44b2xsLDExMTzwwAMAPPXUU/zxxx/prw8YMACA1q1b35E8LQUGBjJ06FBcXFwYMGAA3377bZbfp5MnT1KjRg0CAgIAKFeuXPrrWXF1dWXgwIHpj7du3Urbtm3x9vZmy5YtHD16lLi4OM6fP0///v0BozajVKlSPPDAA4SGhnLlyhVWrlzJwIEDc7xeXjjvHUfcZbh4CB5+u7AjEQ4uN3cGBcWWlTJPPPEEbdu25ddff6VHjx589dVX1K9fP8vjtdZWnX/WrFkMGDCAefPm8dRTT7F//3601jRv3pxdu3bdcWza8FBWSpcufcf133jjDZ577u7m2Pv372ft2rW88cYbdO/enWnTprF37142b95MYGAgn376KVu2bMkx9jQlShitiFxdXTOdXzl8+DAhISF069YNgKSkJOrXr88LL7yQ6fcpq+9dsWLFMJlM6Y8tl8e6u7vj6uqa/vzzzz9PcHAwtWvXZvr06SQmJqYPV2VmxIgRrFixgsDAQBYvXmz1154bznvHEbrR+FeqxYUT6dChA4GBgQCsWLGCTp06AdCuXTu+//57gPTXMzp9+jT169fnxRdfpG/fvhw+fJiyZcsSFxeX6fHdu3dnwYIF6b9IsxuqcnFxYeLEiZhMJtavX899991HVFRUeuJITk7m6NGjVKxYkbJly7J79+5sYwXo0aMHixcvJj4+HoDz589z5coVLly4QKlSpRg+fDivvPIKBw4cID4+ntjYWHr37s2cOXPSh97SlC9fnooVK6bPXyxbtiz97sMaK1euZPr06YSHhxMeHs6FCxc4f/48ERERmX6fmjRpwoULF9i3bx8AcXFxpKSk4OXlxaFDhzCZTJw7d469e/dmer20hFK5cmXi4+PTFyyUK1cOT09P1qxZA8Dt27dJSEgAjBVuaUNvzZvb948d573jOLUeytaE6t6FHYkQuZKQkICnp2f645deeol58+YxatQoZs2aRZUqVfjf//4HwJw5cxg+fDgff/wxjzzyCOXLl7/rfEFBQSxfvhw3NzeqV6/OtGnT8PDwoGPHjrRo0YJevXrxwgsvpB8/evRoTp06hY+PD25ubowZM+aOid2MlFJMnTqVDz/8kB49evDdd9/x4osvEhsbS0pKCpMmTaJ58+YsWrSIMWPGULp0aR588MFMYwUjcR0/fpz27dsDxuTx8uXLCQ0N5dVXX8XFxQU3Nzfmz59PXFwc/fr1S/+rfPbs2Xedb+nSpYwbN46EhATq16+f/r2zRmBgIL/99tsdz/Xv35/AwEBefvnlTL9PQUFBTJgwgVu3blGyZEk2bdpEx44dqVevHt7e3rRo0YJWrVpler0KFSowZswYvL298fLySh/yAiPpPffcc0ybNg03Nze+/fZb6tevT7Vq1WjatGn6PJM9qexufRyJv7+/Dg4ONh6kJsMH9aDFAOg7r3ADEw7p+PHjNG3atLDDsFpCQgIlS5ZEKUVgYCArV668Y5VNURIfH5++6mvmzJlcvHiRuXPnFnJUji8hIQFvb28OHDiQZTLO7OdaKbVfa21ToZtz3nGc3QVJcTJMJe4Z+/fvZ/z48WitqVChgt3HuPPi119/5f333yclJYW6deuyZMmSwg7J4W3atIlRo0bx0ksvZZk08pNzJo5T68G1uLH/hhD3gM6dO/PXX38VdhhWGTJkCEOGDCnsMJxK165d02t6CoJzTo6HbDR2+iuR95YNQggh7uR8ieN6OFw9KcNUQghhJ86XOE6ZN21qLG1GhBDCHpwvcYSsB48GUKlBYUcihBBOybkSR1ICnNkuw1TCKSilePnll9Mff/TRR0yfPj3b9/z000/MnDkzz9desmQJVapUwc/Pj+bNm/P444+nF5oVtNWrV6OU4sSJE4VyfXE350ocZ/6A1Nuy259wCiVKlOCHH37g6tWrVr+nb9++dzUOzK0hQ4Zw6NAhjh49SvHixdO70Ba0lStX0qlTp2yrzPNDUW9lXpQ4V+IIWQ9upY0VVUI4uGLFijF27NhMq6B//vln2rZtS8uWLenatSuXL18GSG/bHRsbi5eXV3pfpISEBGrXrk1ycjJhYWH07NmT1q1b07lz5xz/kk9JSeHmzZtUrFgxy2ubTCYaNWpEVFQUACaTiYYNG3L16lWioqIYOHAgAQEBBAQE8OeffwLw+++/4+fnh5+fHy1btsy09Ul8fDx//vknixYtuitxfPjhh3h7e+Pr65ueLDNrOb5t2zYeffTR9PeNHz8+vXbEy8uLGTNm0KlTJ7799lu+/PJLAgIC8PX1ZeDAgel3WZcvX6Z///74+vri6+vLzp07efvtt+8oXHzrrbeYN+/eKDh2rjqOkI1G7UaxEoUdiXAmv02BS3/n7zmre0OvnIeUXnjhBXx8fHjttdfueL5Tp07s3r0bpRRfffUVH374IR9//HH66+XLl8fX15fff/+dhx56iJ9//pkePXrg5ubG2LFjWbBgAY0aNWLPnj08//zzmTYEDAoKYseOHVy8eJHGjRvTp0+fbK89fPhwVqxYwaRJk9i0aRO+vr5UrlyZJ554gsmTJ9OpUyfOnj1Ljx49OH78OB999BGfffYZHTt2JD4+Hnd397tiWLNmDT179qRx48Z4eHhw4MABWrVqxW+//caaNWvYs2cPpUqVSu+jlVnL8XPnzmX7PXZ3d0/vMnzt2jXGjBkDwNSpU1m0aBETJkzgxRdf5IEHHmD16tWkpqYSHx9PzZo1GTBgQHqPrsDAwCx7TzkbuyYOpVRPYC7gCnyltZ6Z4fU6wFKggvmYKVrrtUqpSsB3QACwRGuddYOcNMmJEHsO7n8ln78KIQpPuXLlGDlyJPPmzbujDXpkZCRDhgzh4sWLJCUlUa9evbvem7YfxEMPPURgYCDPP/888fHx7Ny5M70FOxiN8jIzZMgQPv30U7TWvPDCC8yaNYspU6Zkee1Ro0bRr18/Jk2alL7vBhhVzceOHUs/740bN4iLi6Njx4689NJLPPnkkwwYMOCOvlxpVq5cyaRJkwAYOnQoK1eupFWrVmzatIlnnnkmvX26h4dHpi3HrWFZjHjkyBGmTp1KTEwM8fHx9OhhrM7csmVL+ha0rq6ulC9fnvLly1OpUiUOHjzI5cuXadmyJZUqVbLqmo7ObolDKeUKfAZ0AyKBfUqpn7TWxywOmwqs0lrPV0o1A9YCXkAi8DbQwvyRs9vmPYBlYlzkNyvuDOxp0qRJtGrVKv0XMcCECRN46aWX6Nu3L9u2bct00rxv37688cYbREdHs3//fh5++GFu3rxJhQoV7uoemx2lFH369OGTTz5hypQpWV67du3aVKtWjS1btrBnzx5WrFgBGMNWu3btumv/jylTpvDII4+wdu1a2rVrx6ZNm2jSpEn669euXWPLli0cOXIEpRSpqakopfjwww+zbGWemexamcOdrdyffvpp1qxZg6+vL0uWLEnfnS8ro0ePZsmSJVy6dIlRo0Zle6wzseccRxsgVGt9WmudBAQC/TIco4Fy5s/LAxcAtNY3tdY7MBKIdRJvQDVvKFczz4ELUZR4eHgwePBgFi1alP5cbGwstWrVAshyp7cyZcrQpk0bJk6cyKOPPoqrqyvlypWjXr166ZsQaa2talWyY8cOGjRokOO1R48ezfDhwxk8eHD63hLdu3fn008/TT8mLWmFhYXh7e3N66+/jr+//11zLd999x0jR44kIiKC8PBwzp07R7169dixYwfdu3dn8eLF6XMQ0dHRWbYcr1u3LseOHeP27dvExsayefPmLL/OuLg4atSoQXJycnriA+jSpQvz588HjEn0GzeMHSH79+/PunXr2LdvX/rdyb3AnomjFmA5uBhpfs7SdGC4UioS425jgi0XUEqNVUoFK6WCSbopq6mE03r55ZfvWF01ffp0Bg0aROfOnalcuXKW7xsyZAjLly+/YzhmxYoVLFq0CF9fX5o3b55lF92goKD0/ckPHjzI22+/neO1+/btS3x8/B13R/PmzSM4OBgfHx+aNWuWvrXtnDlzaNGiBb6+vpQsWZJevXrdca6VK1emDzulGThwIN988w09e/akb9+++Pv74+fnl76v+LJly5g3bx4+Pj506NCBS5cuUbt2bQYPHoyPjw9PPvkkLfOH4ZwAAAuLSURBVFu2zPL79Z///Ie2bdvSrVu3O+5+5s6dy9atW/H29qZ169YcPXoUgOLFi/PQQw/dkSjvBXZrq66UGgT00FqPNj8eAbTRWk+wOOYlcwwfK6XaA4uAFlprk/n1pwF/a+Y4/Gu66uDdO6FOWzt8NeJe42ht1YuK4OBgJk+enL5hkrMzmUy0atWKb7/9lkaNGhV2ODnKr7bq9rzjiARqWzz2xDwUZeFZYBWA1noX4A5k/edTdtzLg6dNX7sQIh/NnDmTgQMH8v777xd2KAXi2LFjNGzYkC5dujhE0shP9lxVtQ9opJSqB5wHhgJPZDjmLNAFWKKUaoqROKJydTWP+uBy79wqClHUTJkyJd+KDx1Bs2bNOH36dGGHUSjslji01ilKqfHAeoyltou11keVUjOAYK31T8DLwJdKqckYE+VPa/PYmVIqHGPivLhS6jGge4YVWUIIIQqBXes4tNZrMSa9LZ+bZvH5MSDTMm+ttZc9YxMiJ5kt+RTCUeXnfLZztRwRIp+4u7tz7dq1fP2fTYjCorXm2rVrVhdF5sS5Wo4IkU88PT2JjIxM770khKNzd3fPtDo/NyRxCJEJNze3TNt4CCFkqEoIIYSNJHEIIYSwiSQOIYQQNrFby5GCppSKAiLsdPrKgPXbsBU+R4sXJOaC4GjxguPF7GjxAtyntS5ryxucZnJca13FXudWSgXb2sulMDlavCAxFwRHixccL2ZHixeMmG19jwxVCSGEsIkkDiGEEDaRxGGdhYUdgI0cLV6QmAuCo8ULjhezo8ULuYjZaSbHhRBCFAy54xBCCGETSRwWlFKLlVJXlFJHLJ7zUEptVEqFmP+tWJgxZqSUqq2U2qqUOq6UOqqUmmh+vkjGrZRyV0rtVUr9ZY73HfPz9ZRSe8zxBimlihd2rBkppVyVUgeVUr+YHxfpmJVS4Uqpv5VSh9JWzhTVnwsApVQFpdR3SqkT5p/n9kU83vvM39u0jxtKqUlFOeb/b+/cg62q6jj++dY1hSuCohDCOISBSSoXLLzx6IGYQoyPpnEwp2EmKisqX+ngNBo6ZJga9G4QoiYKiyBt0JJAw0FIg8ujC0RJOgHy0AQlNAT59cf6Xdkcz7mXXfdy9qXfZ2bPWXvttdb+7nXW2b+9197n9wOQdL3/9holzfHfZK6xHIbjcH4MXFKSNxFYbGZ9gcW+XiQOADea2dlAPTBBUn+Kq3sfMMLMBgB1wCWS6oG7gKmudxcpOmTRuBbYkFlvD5o/ZGZ1mVdEizouAL4F/M7M3gUMIPV1YfWa2Ubv2zrgfOAV4NcUWLOknsCXSCG5zyHFShpL3rFsZrFkFqA30JhZ3wj08HQPYGO1Nbag/0HgovagG+gINAAXkP40VeP57wMeqba+Eq29SCeBEcACQO1A87PAqSV5hRwXpKBtz+DPXYuut4z+DwNPFF0z0BPYDJxC+h/fAuDivGM57jhapruZbQPwz25V1lMRSb2BgcCTFFi3T/msBnYCvwc2AbvN7IAX2UIa4EViGnAzcNDXu1J8zQYslLRS0mc8r6jjog8pbPQsnw6cIamW4uotZSwwx9OF1WxmW4F7SGG7twEvASvJOZbDcBwjSDoRmAdcZ2YvV1tPc5jZ65Zu73sBg4GzyxU7uqoqI2kMsNPMVmazyxQtjGZnqJkNAkaRpjDfX21BzVADDAJ+YGYDgb0UaIqnOfx5wKXA3GpraQl/3nIZ8A7gdKCWND5KaXYsh+FomR2SegD4584q63kTko4jGY2fmdl8zy68bjPbDfyB9Gymi6QmFzi9gOeqpasMQ4FLJT0L3E+arppGsTVjZs/5507S3PtgijsutgBbzOxJX/8VyZAUVW+WUUCDme3w9SJrHgk8Y2bPm9l+YD4whJxjOQxHy/wGGOfpcaRnCIVBKSj2TGCDmX0zs6mQuiWdJqmLpzuQBvIG4DHgY16sMHoBzOwWM+tlZr1JUxKPmtnVFFizpFpJnZrSpDn4Rgo6LsxsO7BZ0lmedSGwnoLqLeEqDk1TQbE1/wOol9TRzx1N/ZxvLFf7YU2RFtKXvw3YT7oCGk+ay14M/M0/T6m2zhLNw0i3lWuB1b6MLqpu4DxglettBG7z/D7AU8DTpFv+46uttYL+DwILiq7Zta3xZR3wFc8v5LhwbXXACh8bDwAnF1mva+4I/BPonMkruubbgb/47++nwPF5x3L8czwIgiDIRUxVBUEQBLkIwxEEQRDkIgxHEARBkIswHEEQBEEuwnAEQRAEuQjDEbQJkrpmvIZul7Q1s35EXmQlzcq811+pzARJV7eO6rZpX9IFkqa2lqajiaQR7oQyCN4gXscN2hxJk4B/mdk9JfkijcGDZSsG/xWSauyQ36H/ta3JwAtmNq012guODeKOIziqSHqnxwH4Ickzbg9J0yWt8BgBt2XKLpVUJ6lG0m5JU5TieCyX1M3LTJZ0Xab8FKV4HxslDfH8WknzvO4c31ddGW13S1ovaa2ku7LtK8U9ycZeOCipp6TukuZ7m0+VuzqXNFLSA5n2ZkpaIunvkiaUKd90vFMlNSjFdOjq2/pKesQdFz4uqZ/nz5Z0r6THgDsldZL0E6V4HGslXe7lRnn/NSjFXaj1/C2SJik5GFwrqZ+kM4FPATf5MQ+RdJlS3IZVkhZmvodukhZ7u9/3O8wmDwHjvG9W+7Y477Rz4gsMqkF/YKaZDbTkrXOipXgRA4CLlOKJlNIZWGIpjsdy4JMV2paZDQZuApqM0BeB7V53CsmD8OGVpO6kf9y/28zOA76e3W5mm+1Q7IVZwP2u/dvAN1z/lcCMIzj+fiTX9/XAHZLeWuF4/2jJSeFy4FbPnw583szOB24BvpupcyZwoZndDEwCnjezc0n9usRP8hO9zCDSP7SvzdTfYcnB4AzgBjPb5Om7/diXAY8D9V5uPnCj172DFEtjEPAwyYEeks4BrgCGeN/VkNy2BO2YmpaLBEGrs8nM/pRZv0rSeNJ4PJ1kWNaX1HnVzH7r6ZXA8Aptz8+U6e3pYaRANZjZGknrytR7keQy/T5JD5HiFLwJJQ+z47xNSL62zkqzbgCcLKmDmb1aQR8klyWvATslvQicBmwvKXOAQ95WZwM/9yv4emBeZn/Z3/DczLTfSOByP2YDdvldR39gmdd/G7A0Uz/bd6MraD8D+KWkt5NcVfzV84cBX/P9LZC0J6PjvcAK32cHUjyIoB0ThiOoBnubEpL6kq56B5vZbkmzgRPK1Hktk36dymN3X5ky5VygH4aZ7Zf0HtKdwFjgcyTHgG+gFD1tOjDGzF7JtD3YDcGRsi+TrnQspQ8fzff1gl+5l2NvJq0ybYh0V/CJFnQ117/fA+40s4cljeSQ6/NKfSzgR2Z2a4XtQTskpqqCanMSsAd4WckF9cVtsI+lpGkkJJ1Luuo+DCVPsieZ2QLgekqms5TeBJsLfNnMns5sWgRMyJSrdFLPy3HARz39cWCpme0Ctkm6wvf1FkkDKtRfCHzBy0kpDsMy4AOS+nh+rRvu5tgDdMqsdwa2Kt0+jMvkZ/t4dKbOIuBKSaf6tq6Szmhhn0HBCcMRVJsG0rRUI3Af8EQb7OM7QE9Ja0lz8o2kyGdZOgMPSVoDPArcULJ9OMmYTM48IO9GMhpD/YHyeuDTraT5JWCQpAbSNNBkzx8LfNZ1rgPGVKh/O9BdUiPJY/JwS/EixgO/8PrLSM9bmuNB0ol/ldLLBpNIsT2WADsy5b4KfMT1jvBte83sz65lkff/QqD7EfZBUFDiddzgmEcpQE2Nmf3br7AXAn1b65XV1sb1vmBmXaqt5UiRdAJwwMwOSBoGTPMXBoJjkHjGEfw/cCKw2E/IAq4pqtFox/QG5vgbYvuAa6orJ2hL4o4jCIIgyEU84wiCIAhyEYYjCIIgyEUYjiAIgiAXYTiCIAiCXIThCIIgCHIRhiMIgiDIxX8AA+qj1QYqx+UAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Deviding into test and train - Train:test :: 80%:20%\n",
    "\n",
    "def frange(start, stop, step):\n",
    "    i = start\n",
    "    while i < stop:\n",
    "        yield i\n",
    "        i += step\n",
    "\n",
    "AccuracylistLog = []\n",
    "AccuracylistNB = []\n",
    "\n",
    "for i in frange(0.05,0.85,0.05):\n",
    "    X_train_text = df['review'][:int(len(df)*i)]\n",
    "    yTrain = df['Recommended'][:int(len(df)*i)]\n",
    "\n",
    "    X_valid_text = df['review'][int(len(df)*0.8):]\n",
    "    yValid = df['Recommended'][int(len(df)*0.8):]\n",
    "\n",
    "    total = len(X_train_text) + len(X_valid_text)\n",
    "    #print(\"Total number of records = %d\" %total)\n",
    "    #print(\"Train and Test : %s and %s\" %(yTrain.shape, yValid.shape))\n",
    "\n",
    "    vect = CountVectorizer(binary = False, min_df = 5, stop_words = 'english')\n",
    "\n",
    "    XTrain = vect.fit_transform(X_train_text)\n",
    "    #print(XTrain.shape)\n",
    "\n",
    "    XValid = vect.transform(X_valid_text)\n",
    "    #print(XValid.shape)\n",
    "\n",
    "    LogR = LogisticRegression(C = 5)\n",
    "    LogR.fit(XTrain, yTrain)\n",
    "    \n",
    "    MNB = MultinomialNB(1e-5)\n",
    "    MNB.fit(XTrain, yTrain)\n",
    "\n",
    "    PreditedLog = LogR.predict(XValid)\n",
    "    PreditedNB = MNB.predict(XValid)\n",
    "\n",
    "    AccLog = accuracy_score(yValid, PreditedLog)\n",
    "    AccNB = accuracy_score(yValid, PreditedNB)\n",
    "\n",
    "    AccuracylistLog.append(AccLog)\n",
    "    AccuracylistNB.append(AccNB)\n",
    "    \n",
    "\n",
    "AccuracyLog = np.array(AccuracylistLog)\n",
    "AccuracyNB = np.array(AccuracylistNB)\n",
    "\n",
    "xaxis = np.arange(5,85,5)\n",
    "plt.plot(xaxis,AccuracyLog , label = 'Logistic Regression Accuracy')\n",
    "plt.plot(xaxis,AccuracyNB , label = 'Naive Bayes Accuracy')\n",
    "\n",
    "plt.xlabel('Training size in percentage')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.xlim(xaxis.min(), xaxis.max())\n",
    "plt.legend(loc = 'lower right')\n",
    "plt.show()"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}