other_project2_part3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries in this cell\n",
    "\n",
    "import pandas as pd #pandas is a library for data wrangling/handling\n",
    "import numpy as np #same case for numpy\n",
    "import random\n",
    "\n",
    "# Libraries for helping us with strings\n",
    "import string\n",
    "# Regular Expression Library\n",
    "import re\n",
    "\n",
    "# Seaborn / matplotlib for visualization \n",
    "import seaborn as sns\n",
    "# This command tells python to use seaborn for its styling.\n",
    "sns.set()\n",
    "\n",
    "\n",
    "# Matplotlib is also a very useful, basic visualization/plotting library\n",
    "import matplotlib.pyplot as plt\n",
    "# Very important, this will make your charts appear in your notebook instead of in a new window.\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "# Provides z-score helper function,\n",
    "# z-score uses standard deviation to remove outliers\n",
    "# (industry standard is if a data point is 3 std devs away from mean,\n",
    "# it's considered to be an outlier)\n",
    "import scipy.stats as stats\n",
    "\n",
    "\n",
    "# Ignore this, this is just for displaying images.\n",
    "from IPython.display import Image\n",
    "\n",
    "\n",
    "# Importing sklearn library\n",
    "import sklearn\n",
    "\n",
    "# Import the trees from sklearn\n",
    "from sklearn import tree\n",
    "\n",
    "# Metrics help us score our model, using metrics to evaluate our model\n",
    "from sklearn import metrics\n",
    "\n",
    "# Import our Random Forest Classifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "# Import our Random Forest Regressor\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "# Import our text vectorizers\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "# This is our Logit model\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "# Importing our linear regression model\n",
    "from sklearn.linear_model import LinearRegression\n",
    "\n",
    "# Helper fuctions to evaluate our model from sklearn, including f1_score.\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",
    "from sklearn.metrics import f1_score, roc_auc_score\n",
    "# Some more helpful ML function\n",
    "from sklearn.metrics import confusion_matrix, plot_confusion_matrix\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# Helper function to split our data for testing and training purposes\n",
    "from sklearn.model_selection import train_test_split\n",
    "# Helper function for hyper-parameter turning.\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "# Import MultinomaialNB classifier\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "\n",
    "# Import our Decision Tree\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "from sklearn.svm import SVC\n",
    "\n",
    "\n",
    "# Library for visualizing our tree\n",
    "# If you get an error, \n",
    "# run 'conda install python-graphviz' in your terminal (without the quotes).\n",
    "import graphviz \n",
    "\n",
    "\n",
    "# NLTK is our Natural-Language-Took-Kit\n",
    "import nltk\n",
    "from nltk import word_tokenize\n",
    "from nltk.corpus import stopwords, wordnet\n",
    "from nltk.stem import PorterStemmer, WordNetLemmatizer, SnowballStemmer\n",
    "from nltk.tokenize import RegexpTokenizer\n",
    "\n",
    "# You may need to download these from nltk\n",
    "# nltk.download('stopwords')\n",
    "# nltk.download('punkt')\n",
    "# nltk.download('wordnet')\n",
    "# nltk.download('averaged_perceptron_tagger')\n",
    "stopwords = stopwords.words('english')\n",
    "\n",
    "import pickle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NAME YOUR MODEL \n",
    "filename = 'data1/comments.pkl'\n",
    "\n",
    "## HOW TO LOAD IT FOR FUTURE USE\n",
    "df = pickle.load(open(filename, 'rb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 -1 0]\n"
     ]
    }
   ],
   "source": [
    "print(df.category.unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Seems like good practice to me, creating a single function that will call all\n",
    "# our necessary functions from one place, will be subject to change\n",
    "translator = str.maketrans('', '', string.punctuation)\n",
    "\n",
    "def text_pipeline(input_str):\n",
    "    input_str = remove_profanity(input_str)\n",
    "    return input_str\n",
    "\n",
    "def mk_lower(a):\n",
    "    return a.lower()\n",
    "\n",
    "def remove_stopwords(a):\n",
    "    return \" \".join([word for word in word_tokenize(a) if word not in stopwords])\n",
    "\n",
    "def remove_sp_char(a):\n",
    "    ## \\s for white space, ^ is negation, \\w is words.  so replace all punctutation that follows a word \n",
    "    return a.translate(translator)\n",
    "\n",
    "def remove_sp_char2(a):\n",
    "    return re.sub(r\"[^\\w\\s]\", \"\", a)\n",
    "    \n",
    "    \n",
    "def text_pipeline2(a):\n",
    "    a = mk_lower(a)\n",
    "    a = remove_sp_char(a)\n",
    "    a = remove_stopwords(a)\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0]\n"
     ]
    }
   ],
   "source": [
    "mask1 = df[\"category\"] == -1\n",
    "\n",
    "df.loc[mask1, 'category'] = 0\n",
    "print(df[\"category\"].unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(227016, 2)\n"
     ]
    }
   ],
   "source": [
    "new_df = pd.DataFrame()\n",
    "new_df[\"clean_comment\"] = df[\"clean_comment_profane_free\"].copy()\n",
    "new_df[\"category\"] = df[\"category\"].copy()\n",
    "new_df.dropna(inplace=True)\n",
    "\n",
    "print(new_df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['clean_comment', 'category'], dtype='object')\n",
      "[1 0]\n",
      "(227016, 2)\n"
     ]
    }
   ],
   "source": [
    "print(new_df.columns)\n",
    "print(new_df.category.unique())\n",
    "print(new_df.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = new_df[\"clean_comment\"].values\n",
    "y = new_df[\"category\"].values\n",
    "y=y.astype('float')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(227016, 1769186) <class 'scipy.sparse.csr.csr_matrix'>\n"
     ]
    }
   ],
   "source": [
    "vectorizer = TfidfVectorizer(ngram_range=(1,2))\n",
    "vectorizer.fit(X)\n",
    "\n",
    "X = vectorizer.transform(X)\n",
    "\n",
    "print(X.shape, type(X))\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=33)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'alpha': 0.5}\n"
     ]
    }
   ],
   "source": [
    "params = {\n",
    "    'alpha' : [0.45, 0.5, 0.55]\n",
    "}\n",
    "\n",
    "grid_search_cv = GridSearchCV(\n",
    "    estimator = MultinomialNB(),\n",
    "    param_grid = params,\n",
    "    scoring = 'accuracy'\n",
    ")\n",
    "\n",
    "grid_search_cv.fit(X_train, y_train)\n",
    "print(grid_search_cv.best_params_)\n",
    "\n",
    "model = grid_search_cv.best_estimator_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Saving the vectorizer \n",
    "pickle.dump(vectorizer, open('data1/our_vectorizer.pkl', 'wb') )\n",
    "\n",
    "# Saving the model\n",
    "pickle.dump(model, open('data1/comments_model.pkl', 'wb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model Accuracy: 0.773280\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.confusion_matrix.ConfusionMatrixDisplay at 0x22e8cf29670>"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsQAAAJVCAYAAADZb+NlAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAABHDUlEQVR4nO3de1zW9f3/8ecHLvCEiCwIpmbNSk2bWpTNDK3N1IBspi0lbbkOc+FhfUfhYfLT8jBj5prhrKy2oiVZQhnS2cxspaws0zyUeADiICiHBOHi+v1BXosUrjx8Lrg+n8e923Wz63NdfD6vz/S2Xj17fd5vw+VyuQQAAADYlF9LFwAAAAC0JBpiAAAA2BoNMQAAAGyNhhgAAAC2RkMMAAAAW6MhBgAAgK3REAMAAFhU6ZGqli7BJxi+vA7xdb9doryiwy1dBlqhnVnz1POGOS1dBlqpz16Z19IloBVr45Bq6lq6CrRWbRwtXcGp++UdS3Sw8LCp1+h6bojefvo+U69hJh/8bf2fvKLD2l9Q2tJloJXizwaa4rMpALyGPyM4GaOlCzhNBwvplzzx6YYYAAAAHhh+DS+zr+HDfLt6AAAA4AyREAMAAFiZYTS8zL6GDyMhBgAAgK2REAMAAFiZYXhhhti3E2IaYgAAAHjVsmXLtG7dOknSkCFDdP/992vVqlV69tlnZRiG+vbtq7lz5yowMFDLli3TSy+9pODgYEnSLbfcovj4eOXn5ysxMVGHDh3SBRdcoJSUFHXo0EHl5eX605/+pAMHDig0NFRLly5VWFhYs/UwMgEAAGBlx2eIzX79SJs2bdLGjRu1Zs0aZWRk6IsvvtDjjz+ulStX6oUXXtArr7yi+vp6Pf/885Kkbdu2acmSJcrMzFRmZqbi4+MlSXPnztX48eOVnZ2tvn37KjU1VZK0dOlSRUVFad26dRo7dqzmz5/vsSYaYgAAAHhNWFiYkpKSFBgYqICAAPXo0UPHjh1TcnKygoKCZBiGLr74YuXn50tqaIhXrFihuLg4zZs3TzU1NaqtrdXmzZs1fPhwSdLo0aOVnZ0tSVq/fr3i4uIkSbGxsdqwYYNqa2ubrYmGGAAAwMqOr0Ns9ktSQUGBDh482OhVXl7eqJyLLrpI/fv3lyTl5uZq3bp1io2N1dVXXy1JKi0tVVpamn75y1+qqqpKvXv3VmJiotasWaPy8nKlpqaqrKxMQUFBcjgapn/DwsJUWFgoSSoqKnKPSDgcDgUFBam0tPmNSZghBgAAwFkRHx+vvLy8RscSEhI0ZcqUE767e/du3XPPPbr//vt1/vnnS5IKCwt155136uabb9bAgQMlSU888YT7ZyZNmqSZM2dq/PjxMn4wpvHD98e5XC75+TWfAdMQAwAAWJkX1yFOS0uT0+ls9NHxh+G+LycnR1OnTtXMmTMVExMjSfrqq6905513asKECZo0aZIkKT8/X5s2bdKYMWMkNTS3DodDoaGhqqiokNPplL+/v4qLixUeHi5JCg8PV0lJiSIiIlRXV6eqqiqFhIQ0Wz4jEwAAADgrIiMj1bVr10avHzbEBQUFuvfee5WSkuJuhisrK/W73/1O06ZNczfDktS2bVs9/PDDOnDggFwul9LS0jRs2DAFBAQoKipKWVlZkqSMjAxFR0dLali1IiMjQ5KUlZWlqKgoBQQENFs3CTEAAAC8ZuXKlaqpqdGiRYvcx2644QaVlJTo6aef1tNPPy1Juu666zRt2jTNmzdPkydPVm1trS677DLdcccdkqTk5GQlJSVp+fLlioyM1JIlSyRJ06ZNU1JSkmJiYtSxY0elpKR4rMlwuVwuE+7VK3reMEf7C5ofkoY9Hf1kmdoNSGjpMtBKlW1e1tIloBVr65Cq61q6CrRGhqQ2Phgl9vz1Iu0vKDP1GudFdtbONUmmXsNMjEwAAADA1nzw33MAAADw43nhoTr59tbNJMQAAACwNRJiAAAAKzMM98YZpl7Dh5EQAwAAwNZIiAEAAKzMixtz+CoSYgAAANgaCTEAAICVGX5emCH27YzVt6sHAAAAzhAJMQAAgJUxQ+wRCTEAAABsjYQYAADAypgh9si3qwcAAADOEAkxAACAlbFTnUckxAAAALA1EmIAAAArMwzJj1UmmkNCDAAAAFujIQYAAICtMTIBAABgZSy75pFvVw8AAACcIRJiAAAAK2PrZo9IiAEAAGBrJMQAAABWxgyxR75dPQAAAHCGSIgBAACszJAXZojNPb3ZSIgBAABgayTEAAAAVsYMsUe+XT0AAABwhkiIAQAArIx1iD0iIQYAAICtkRADAABYGTPEHvl29QAAAMAZIiEGAACwNC/MEPv4QsQkxAAAALA1GmIAAADYGiMTAAAAVmYYXniojpEJAAAAwGeREAMAAFgZG3N4REIMAAAAWyMhBgAAsDI25vDIt6sHAAAAzhAJMQAAgJWREHvk29UDAAAAZ4iEGAAAwMpYZcIjEmIAAADYGgkxAACAlbFTnUckxAAAALA1EmIAAAArY4bYIxJiAAAA2BoJMQAAgKV5YR1iH89Yfbt6AAAA4AzREAMAAMDWGJkAAACwMh6q84iEGAAAALZGQgwAAGBhhmHIMDnBNfv8ZiMhBgAAgK2REAMAAFgYCbFnJMQAAADwqmXLlikmJkYxMTFavHixJGnTpk2Ki4vT9ddfr0ceecT93R07dmj06NEaPny4Zs2apbq6OklSfn6+4uPjNWLECE2ePFlVVVWSpPLyct19990aOXKk4uPjVVxc7LEeGmIAAAArM7z0+pE2bdqkjRs3as2aNcrIyNAXX3yhtWvXaubMmUpNTVVWVpa2bdum9957T5KUmJioOXPm6PXXX5fL5VJ6erokae7cuRo/fryys7PVt29fpaamSpKWLl2qqKgorVu3TmPHjtX8+fM91kRDDAAAAK8JCwtTUlKSAgMDFRAQoB49eig3N1fdu3dXt27d5HA4FBcXp+zsbOXl5am6ulr9+/eXJI0ePVrZ2dmqra3V5s2bNXz48EbHJWn9+vWKi4uTJMXGxmrDhg2qra1ttiZmiAEAACzMmzPEBQUFcjqdjT4LDg5WcHCw+/1FF13k/vvc3FytW7dOt912m8LCwtzHw8PDVVhYqKKiokbHw8LCVFhYqLKyMgUFBcnhcDQ6LqnRzzgcDgUFBam0tFTnnntuk/XTEAMAAOCsiI+PV15eXqNjCQkJmjJlygnf3b17t+655x7df//98vf3V25urvszl8slwzBUX1/fqJk/fvz4r9/XVNPvcrnk59f8UAQNMQAAgIU1bFRndkLc8GtaWtpJE+IfysnJ0dSpUzVz5kzFxMTo448/bvTwW3FxscLDwxUREdHoeElJicLDwxUaGqqKigo5nU75+/u7vy81pMslJSWKiIhQXV2dqqqqFBIS0mz9zBADAADgrIiMjFTXrl0bvX7YEBcUFOjee+9VSkqKYmJiJEn9+vXT3r17tW/fPjmdTq1du1bR0dHq0qWL2rRpo5ycHElSZmamoqOjFRAQoKioKGVlZUmSMjIyFB0dLUkaMmSIMjIyJElZWVmKiopSQEBAs3WTEAMAAFhYa1uHeOXKlaqpqdGiRYvcx2699VYtWrRIU6ZMUU1NjYYMGaIRI0ZIklJSUjR79mxVVlaqT58+mjhxoiQpOTlZSUlJWr58uSIjI7VkyRJJ0rRp05SUlKSYmBh17NhRKSkpnut3uVyuU7nh1qTnDXO0v6C0pctAK3T0k2VqNyChpctAK1W2eVlLl4BWrK1Dqq5r6SrQGhmS2vhglNh3ykvaX1xl6jXOC+ugbX+/2dRrmMkHf1sBAADwYxnyQkJ8KgsRt0LMEAMAAMDWaIgBAABga4xMAAAAWNkpbq182tfwYSTEAAAAsDUSYgAAAAtrbcuutUYkxAAAALA1EmIAAAAr80JCLBJiAAAAwHeREAMAAFgYM8SekRADAADA1kiIAQAALIyE2DMSYgAAANgaCTEAAICVsVOdRyTEAAAAsDUSYgAAAAtjhtgzEmIAAADYGgkxAACAhRkyP8H17XyYhBgAAAA2R0MMAAAAW2NkAgAAwMJ4qM4zEmIAAADYGgkxAACAlbExh0ckxAAAALA1EmIAAAALY4bYMxJiAAAA2BoJMQAAgIWREHtGQgwAAABbIyEGAACwMi8kxCIhBgAAAHwXCTEAAICFMUPsGQkxAAAAbI2EGAAAwMrYqc4jEmIAAADYGgkxAACAhRnywgyxj0fEJMQAAACwNRpiAAAA2BojEwAAABbGsmuekRADAADA1kiIAQAALMwwzE9wfTwgJiEGAACAvZEQAwAAWBkbc3hEQgwAAABbIyEGAACwMFaZ8IyEGAAAALZGQgwAAGBhJMSekRADAADA1kiIAQAALIyE2DMaYrRat4y8QlNu+6Vcko5WH9MDKav15dcFevj+W3R5n+6SYShnW64SF6eruqZWgy+/SA9NHy2Hv5+OOaW+F3XRtt15kqR7469T/I2/kLPOqZLDlfrjgheUm1ei11fep3ZtA93XvPC8cP0rY5OS/rq6he4awNm2Kutj/f25t2VIatc2UH/50xgNuKS7evzqAf00PMT9vSkTfqVbRl6h9zbv0v1/fVl1znqFduqgBffdrEsv7tronMuff1f/ytykD1fN8u7NADCFqQ3xq6++quXLl6uurk6333674uPjG32+Y8cOzZo1S1VVVYqKitLcuXPlcNCjQ7qwe7jmTr1JQ2/7iwoPlWvYoEv07OI79cJrH8vh76erxy2UYUiPz7tdf/zt9Xrsubf17OK7dHvSk9qweZeq/rtMTy2cpMHjFuoXA3rotht/oesn/VUVVdX63Zhr9Nic2xRzz1IN/90S9zVHRl+qOffeqAX/WNuCdw7gbNqdW6jkRzO0/rkHFHFOJ73xwReacP+TWrMsQZ07tdf7z89o9P0jlUd16/89oWcW3akhV/bUrtxvFP9/j2vjv2eoTWCAJOk/W7/So8++qZDgDi1xS8Cp80JC7Otb1Zk2Q1xYWKhHHnlEzz//vDIyMrRq1Srt2bOn0XcSExM1Z84cvf7663K5XEpPTzerHPiYmmN1mvbQ8yo8VC5J+mTHfoX/JFibPtmjlKca/rzU17v02c6D6hYRqp+dF67yyqPasHmXJMnPkCqqqnXFpReo6FC5/u8vq1RRVd1wru371S0ytNH1QoLb669Jt2ry/3tW5d99D4DvaxPo0N9mj1fEOZ0kSQN6n6eiQ+Xa+N/d8vfz08i7HtHV4xZo8RPr5HTW6+v9RQoOaqchV/aUJF18foQ6dmirzZ/vlSQVHSrX/Ytf1Nypv26xewJw9pnWEG/atElXXXWVQkJC1L59ew0fPlzZ2dnuz/Py8lRdXa3+/ftLkkaPHt3oc9jbgYJSvfHBF+738/84Wus2fK53P/pSX+0vkiR1i+is34+7Vplvf6Kv9hepfbtAXTuwlySp3iX1+lmkIs4J1o6vCrTpvw3/MhYY4FBywo3KePuTRtebPnGY3vzgC326Y7+X7hCAN5z3059o+OC+kiSXy6VZj7yskdGXys8wNOTKnlr96B+U9fh0vf2fHXp81XvqcV64vj16TO/8Z4ck6b9f7NOXXxfom5JyOZ31umv2M5o7dZR+Gt6pJW8LOHWGyS8fZ9p8QlFRkcLCwtzvw8PD9dlnnzX5eVhYmAoLC80qBz6qfdtAPZZ8m7qc21ljpqa6j/fr1U3PPXyXnkx/T69v3CZJuu1PT2j2H+I0b+pNctZL72/epWO1TvfP/CQkSP/8y+9UXlmtBx97xX28TaBDt//6ag2d+Bfv3RgAr6o6WqN75z6nvMIyrX70D+rUsX2jz++Nv1YrXnhPk8dfq1WP3KU5f39Vcx7N0KABPXTNFRcrMMBfcx97RYMuu1DXDuytjTm7WuhOAJjBtIa4vr6+0byKy+Vq9N7T5z/Gzqx5Z14oWi2XSzrmbBhLCvCTCt9/WJLkrJdq6xuOzZ92o+ZPu1Eul+RSw6jEcSOu6au4oX3lZzQkxseckr8hOfyk8s1/c3/PWS85XdKXa+d6+Q4BeMP+glKNmbZCPS84V288MVXt2gbq+bUf69KLu+jSi7tIkhyG1CbAX4F+9Qpq10ZvrZzu/vlLR81Vr+5heuDhFxXWuaOy1m9V5dEa5Rcd0ZD4hfpo1YwmrgzAV5jWEEdERGjLli3u98XFxQoPD2/0eXFxsft9SUlJo89/jJ43zNH+gtIzLxatTlD7Nnr/+Rn699qPtPjJde7jI67pq0dnx+uW6ctPGG/44rWHFP+nx/Xpjv2qzFmmbbvzNHj8Qv00PEQb0pKU/GiG0l79zwnXWnDfzTp0uFJ/fep10+8LrUPZ5mUtXQK8pKKqWtff+TeNix2oB+66QZJUXSdt3Z2vl976VP/6y506Vlun1Bfe09gRV6jGaeimKcuVlnK3BlzSXS+/kaPAwABd9LMu2rFugfu8G3N2KXHxi3ovbYaq61rq7uBthqQ2PvjsP8uueWbab+ugQYP097//XaWlpWrXrp3eeOMNPfjgg+7Pu3TpojZt2ignJ0eXX365MjMzFR0dbVY58DF33TJE3SJCFXttP8Ve2899vH3bQBmG9Ojs8e5jH239WomL03XXn5/R32aNU0CAQ06XFJ/4uCQp8Xcj1L5toO65dajuuXWopIaH9obdkSJJ6tEtjNlhwKKeSH9PB74p1dp3t2rtu1vdx1ctnawF/1irq8ctUG2dU6N+OUATbxokwzD0zwW/1bT5/1ZtbZ3OPaeT0h6+2+f/YQ+geYbL5XKZdfJXX31VK1asUG1trcaMGaO77rpLd911l6ZOnapLL71UX375pWbPnq3Kykr16dNHCxcuVGBgoOcTf4eEGE05+skytRuQ0NJloJUiIUZz2jpE6ouT8tWEOPqh9corO2rqNbp0bqcNs4eaeg0zmfrbGhcXp7i4uEbHnnjiCfff9+rVS6tXswECAAAAWo4P/nsOAAAAfizDMH/fjNM5f2VlpW699Vb94x//0FdffaUlS/63WVZhYaH69eunFStWaNmyZXrppZcUHBwsSbrlllsUHx+v/Px8JSYm6tChQ7rggguUkpKiDh06qLy8XH/605904MABhYaGaunSpY1WNjsZ09YhBgAAAE5m69atGjdunHJzcyVJQ4YMUWZmpjIzM/Xkk08qKChIM2Y0rOCybds2LVmyxP358Z2P586dq/Hjxys7O1t9+/ZVamrD8qxLly5VVFSU1q1bp7Fjx2r+/Pke66EhBgAAsLDjq0yY/ToV6enpSk5OPukKY4sXL9att96q888/X1JDQ7xixQrFxcVp3rx5qqmpUW1trTZv3qzhw4dLarzB2/r1690ju7GxsdqwYYNqa2ubrYeGGAAAAGdFQUGBDh482OhVXl5+wvfmz5+vqKioE47n5ubq448/1sSJEyVJVVVV6t27txITE7VmzRqVl5crNTVVZWVlCgoKksPRMP37/Q3evr/5m8PhUFBQkEpLm1+EgRliAAAAC/PmDHF8fLzy8vIafZaQkKApU6b8qPOsWrVK48ePd6861qFDh0YLMkyaNEkzZ87U+PHjT0ilm0qpXS6X/Pyaz4BpiAEAAHBWpKWlyel0Njp2/GG4H+Ptt9/WypUr3e/z8/O1adMmjRkzRlJDc+twOBQaGqqKigo5nU75+/s32gAuPDxcJSUlioiIUF1dnaqqqhQSEtLsdRmZAAAAsLCGhNjsGeKGa0VGRqpr166NXj+2IS4tLVV1dbW6devmPta2bVs9/PDDOnDggFwul9LS0jRs2DAFBAQoKipKWVlZkqSMjAz3Bm9DhgxRRkaGJCkrK0tRUVEKCAho9to0xAAAAGhxBw8eVERERKNjoaGhmjdvniZPnqwRI0bI5XLpjjvukCQlJycrPT1dN9xwg7Zs2aLp06dLkqZNm6ZPP/1UMTExev755zVnzhyP1zZ1pzqzsVMdmsJOdWgOO9WhOexUh6b46k51v/zLe8orqzb1Gl06t9XbDwwx9RpmIiEGAACArfngv+cAAADgxzIMQ35+5i4zcarrELc2JMQAAACwNRpiAAAA2BojEwAAABbmzY05fBUJMQAAAGyNhBgAAMDCjm+eYfY1fBkJMQAAAGyNhBgAAMDCmCH2jIQYAAAAtkZCDAAAYGHMEHtGQgwAAABbIyEGAACwMBJiz0iIAQAAYGskxAAAABbGKhOekRADAADA1kiIAQAALM38GWLJtyNiEmIAAADYGgkxAACAhTFD7BkJMQAAAGyNhhgAAAC2xsgEAACAhbExh2ckxAAAALA1EmIAAAAL46E6z0iIAQAAYGskxAAAABbGDLFnJMQAAACwNRJiAAAAC2OG2DMSYgAAANgaCTEAAICFNSTEZs8Qm3p605EQAwAAwNZIiAEAACyMGWLPSIgBAABgayTEAAAAlmb+OsSSb0fEJMQAAACwNRJiAAAAC2OG2DMSYgAAANgaCTEAAICFGYb5M8Tmzyibi4QYAAAAtkZDDAAAAFtjZAIAAMDCeKjOMxJiAAAA2BoJMQAAgIXxUJ1nJMQAAACwNRJiAAAACyMh9oyEGAAAALZGQgwAAGBhrDLhGQkxAAAAbI2EGAAAwMKYIfaMhBgAAAC2RkIMAABgcT4e4JqOhBgAAAC2RkIMAABgYcwQe0ZCDAAAAFsjIQYAALAw1iH2jIQYAAAAtkZDDAAAAFtjZAIAAMDC/AxDfibPNJh9frOREAMAAMDrKisrFRsbq4MHD0qSZsyYoeuvv16jRo3SqFGj9Oabb0qSduzYodGjR2v48OGaNWuW6urqJEn5+fmKj4/XiBEjNHnyZFVVVUmSysvLdffdd2vkyJGKj49XcXGxx1poiAEAACzs+EN1Zr9OxdatWzVu3Djl5ua6j23btk3PPfecMjMzlZmZqWHDhkmSEhMTNWfOHL3++utyuVxKT0+XJM2dO1fjx49Xdna2+vbtq9TUVEnS0qVLFRUVpXXr1mns2LGaP3++x3poiAEAAOBV6enpSk5OVnh4uCTp6NGjys/P18yZMxUXF6dHH31U9fX1ysvLU3V1tfr37y9JGj16tLKzs1VbW6vNmzdr+PDhjY5L0vr16xUXFydJio2N1YYNG1RbW9tsPcwQAwAAWFhDgmv2xhwNvxYUFMjpdDb6LDg4WMHBwY2O/TC1LSkp0VVXXaXk5GR17NhR99xzj1avXq2LLrpIYWFh7u+FhYWpsLBQZWVlCgoKksPhaHRckoqKitw/43A4FBQUpNLSUp177rlN1k9DDAAAgLMiPj5eeXl5jY4lJCRoypQpzf5ct27d9Nhjj7nfT5gwQRkZGerRo0ejZt7lcskwDPev39dU0+9yueTn1/xQBA0xAACAhRmG5OeljTnS0tJOmhB7snPnTuXm5rpHIFwulxwOhyIiIho9FFdSUqLw8HCFhoaqoqJCTqdT/v7+Ki4udo9fhIeHq6SkRBEREaqrq1NVVZVCQkKavT4zxAAAADgrIiMj1bVr10avH9MQu1wuLViwQEeOHFFtba1WrVqlYcOGqUuXLmrTpo1ycnIkSZmZmYqOjlZAQICioqKUlZUlScrIyFB0dLQkaciQIcrIyJAkZWVlKSoqSgEBAc1en4QYAADAwgzD8MIM8Zmdv1evXrr77rs1btw41dXV6frrr1dsbKwkKSUlRbNnz1ZlZaX69OmjiRMnSpKSk5OVlJSk5cuXKzIyUkuWLJEkTZs2TUlJSYqJiVHHjh2VkpLiuX6Xy+U6oztoQT1vmKP9BaUtXQZaoaOfLFO7AQktXQZaqbLNy1q6BLRibR1SdV1LV4HWyJDUxgejxN+mfaqiimOmXiO8Y6Ceie9v6jXM5IO/rQAAAPixDJ36OsGncw1fxgwxAAAAbI2EGAAAwMKM7/4y+xq+jIQYAAAAtkZCDAAAYGF+XliH2Ozzm42EGAAAALZGQwwAAABbY2QCAADAwnxhY46WRkIMAAAAWyMhBgAAsDDD8MLGHL4dEJMQAwAAwN5IiAEAACzMMAz5MUPcLBJiAAAA2BoJMQAAgIUxQ+wZCTEAAABsjYQYAADAwliH2DMSYgAAANgaCTEAAICFMUPsGQkxAAAAbI2EGAAAwML8ZP46xH7y7YiYhBgAAAC2RkIMAABgYcZ3L7Ov4ctIiAEAAGBrNMQAAACwNUYmAAAArMwLG3P4+rprJMQAAACwNRJiAAAAC/MzGl5mX8OXkRADAADA1kiIAQAALKxh62ZzI1wfHyFuuiE+fPhwsz8YEhJylksBAAAAvK/Jhviqq66SYRhyuVwnfGYYhnbs2GFqYQAAADhzDQmx+dfwZU02xF9++aU36wAAAABahMeH6urr67Vy5UolJSWpsrJSK1askNPp9EZtAAAAOEPGd+sQm/3yZR4b4sWLF2vnzp3aunWrXC6X3n//fS1cuNAbtQEAAACm89gQf/jhh1q0aJHatGmjjh076qmnntIHH3zgjdoAAABwho6vQ2z2y5d5bIgdDof8/P73tcDAQDkcrNYGAAAAa/DY2V588cVKS0uT0+nU119/rWeeeUa9evXyRm0AAAA4U96Y8bX6DPGsWbP0xRdf6NChQxo3bpyqqqo0c+ZMb9QGAAAAmM5jQhwUFKQFCxZ4oxYAAACcZcZ3L7Ov4cs8JsSHDh3Sfffdp4EDB2rw4MGaOXOmysvLvVEbAAAAYDqPDfHs2bPVrVs3rV69Ws8995w6deqkOXPmeKM2AAAAwHQeRyby8vK0fPly9/sHHnhAcXFxphYFAACAs8NPhvxMfujNz8eHJjwmxOHh4Tpw4ID7/TfffKOwsDBTiwIAAAC8pcmE+Pe//70kqbS0VDfddJMGDRokPz8/ffTRR+rZs6fXCgQAAMDpMwzzV0Xz8VXXmm6Ihw8fftLjQ4cONasWAAAAwOuabIh//etfn/S4y+XSvn37TCsIAAAAZ4/hhY05TN/4w2QeH6p74YUXtHjxYh09etR9LDQ0VB988IGphQEAAADe4LEhfvzxx/X0009r+fLlmj59ut59911988033qgNAAAAZ4gZYs88rjIREhKifv36qXfv3jp06JAmT56szZs3e6M2AAAAwHQeG2KHw6EjR46oe/fu+uyzzyRJTqfT9MIAAABw5gyjYR1iM1++PkPssSG+5ZZbdM8992jo0KFatWqVRo8erZ/97GfeqA0AAAAwnccZ4jFjxuiGG25Q+/bttWrVKn3++ee65pprvFEbAAAAzhAzxJ412RA//fTTTf7Q888/rzvuuMOUggAAAABvarIh3rVrlzfrAAAAgAlYh9gzw+VyuVq6iNOVs/eIaurqW7oMtEKDLuqsTbvLWroMtFKv7Cpq6RLQii2K6amk13a2dBlohTq3c+iB63q0dBmn7M+v71Hpt7WmXiO0fYAeHH6hqdcwk8cZYgAAAPguP/2IVRTOwjV8ma/XDwAAAJwRGmIAAADYmseGuL6+Xk8++aQeeOABVVZWasWKFWzMAQAA4COOP1Rn9utUVVZWKjY2VgcPHpQkrVq1SrGxsYqLi9OMGTN07NgxSdKyZct07bXXatSoURo1apTS0tIkSfn5+YqPj9eIESM0efJkVVVVSZLKy8t19913a+TIkYqPj1dxcbHHWjw2xIsXL9auXbvcu9S9//77Wrhw4SnfNAAAACBJW7du1bhx45SbmytJ2rt3r1auXKkXXnhBr7zyiurr6/X8889LkrZt26YlS5YoMzNTmZmZio+PlyTNnTtX48ePV3Z2tvr27avU1FRJ0tKlSxUVFaV169Zp7Nixmj9/vsd6PDbEH374oRYtWqQ2bdooKChITz31lD744IPTvX8AAAB4kZ8kP8Pk1ynWlJ6eruTkZIWHh0uSAgMDlZycrKCgIBmGoYsvvlj5+fmSGhriFStWKC4uTvPmzVNNTY1qa2u1efNmDR8+XJI0evRoZWdnS5LWr1+vuLg4SVJsbKw2bNig2trmV9nwWL/D4ZCf3/++FhgYKIeDxSkAAADQWEFBgQ4ePNjoVV5efsL35s+fr6ioKPf7Ll266Oqrr5YklZaWKi0tTb/85S9VVVWl3r17KzExUWvWrFF5eblSU1NVVlamoKAgd08aFhamwsJCSVJRUZHCwsIkNfSxQUFBKi0tbbZuj53txRdfrLS0NDmdTn399dd65pln1KtXrx/5PwsAAABakvFdimv2NSQpPj5eeXl5jT5LSEjQlClTftR5CgsLdeedd+rmm2/WwIEDJUlPPPGE+/NJkyZp5syZGj9+/Alzy03NMbtcrkbh7sl4bIhnzZqlBQsW6NChQxo3bpwGDx6s2bNne7whAAAA2MvxEPX7goODf9TPfvXVV7rzzjs1YcIETZo0SVLDg3ObNm3SmDFjJDU0tw6HQ6GhoaqoqJDT6ZS/v7+Ki4vd4xfh4eEqKSlRRESE6urqVFVVpZCQkGav7bEhDgoK0oIFC37UjQAAAKB1MQzzt1Y+fvrIyMjT+vnKykr97ne/0/Tp03XTTTe5j7dt21YPP/ywBg4cqK5duyotLU3Dhg1TQECAoqKilJWVpbi4OGVkZCg6OlqSNGTIEGVkZOj3v/+9srKyFBUVpYCAgGav77Ehfuihh056nJQYAAAAZ8Pq1atVUlKip59+Wk8//bQk6brrrtO0adM0b948TZ48WbW1tbrssst0xx13SJKSk5OVlJSk5cuXKzIyUkuWLJEkTZs2TUlJSYqJiVHHjh2VkpLi8foeG+LvR8y1tbV69913deWVV57OvQIAAMDL/LwwQ3y653/nnXckSb/97W/129/+9qTfGT58uHs1ie/r0qWLnn322ROOh4SE6B//+Mcp1eGxIU5ISGj0/q677tLkyZNP6SIAAABAa3XK66cFBQWpqKjIjFoAAABwljXMEJt/DV/msSF+8MEH3YPYLpdLX3zxhX72s5+ZXhgAAADgDR4b4s6dOzd6f+ONN+rGG280rSAAAACcPX6GIT+TI1yzz282jw3x/v37tXjxYm/UAgAAAHidx4b4yy+/lMvlMn39OgAAAJx9hqTm92k7O9fwZR4b4rCwMMXExKhfv37q0KGD+zjrEAMAAMAKmmyIjx07psDAQA0YMEADBgzwZk0AAACA1zTZEP/mN7/RmjVrTliHGAAAAL6DZdc8a3KkxOVyebMOAAAAoEU0mRDX1NRo+/btTTbGffr0Ma0oAAAAnB0su+ZZkw3xgQMHNGXKlJM2xIZh6O233za1MAAAAMAbmmyIL7zwQmVkZHixFAAAAJxthrwwQ2zu6U1n9rJ0AAAAQKvWZEIcFRXlzToAAABgAj+j4WX2NXxZkwkxG28AAADADjzuVAcAAADfZXhhlQnDx1eZYIYYAAAAtkZCDAAAYGHsVOcZCTEAAABsjYQYAADAwlhlwjMSYgAAANgaCTEAAICFGd/9ZfY1fBkJMQAAAGyNhhgAAAC2xsgEAACAhfFQnWckxAAAALA1EmIAAAALM7yQELMxBwAAAODDSIgBAAAszDAMGSZHuGaf32wkxAAAALA1EmIAAAAL85MXVpkw9/Sm8/X6AQAAgDNCQgwAAGBhhmH+KhA+PkJMQgwAAAB7IyEGAACwMD/DkJ/JEa7Z5zcbCTEAAABsjYQYAADAwtipzjMSYgAAANgaCTEAAICFscqEZyTEAAAAsDUaYgAAANgaIxMAAAAW5idDfjJ52TWTz282EmIAAADYGgkxAACAhfFQnWckxAAAALA1EmIAAAAL8/PCxhxmn99sJMQAAACwNRJiAAAAC2vYutncCJcZYgAAAMCHkRADAABYmCEvrDJh7ulNR0IMAAAAWyMhBgAAsDA/wzB9htjs85uNhBgAAAC2RkIMAABgYexU5xkJMQAAAGyNhBgAAMDC/GR+AurrCauv1w8AAACcERpiAAAAeF1lZaViY2N18OBBSdKmTZsUFxen66+/Xo888oj7ezt27NDo0aM1fPhwzZo1S3V1dZKk/Px8xcfHa8SIEZo8ebKqqqokSeXl5br77rs1cuRIxcfHq7i42GMtNMQAAABWZhgyTH6d6lN1W7du1bhx45SbmytJqq6u1syZM5WamqqsrCxt27ZN7733niQpMTFRc+bM0euvvy6Xy6X09HRJ0ty5czV+/HhlZ2erb9++Sk1NlSQtXbpUUVFRWrduncaOHav58+d7rIeGGAAAAF6Vnp6u5ORkhYeHS5I+++wzde/eXd26dZPD4VBcXJyys7OVl5en6upq9e/fX5I0evRoZWdnq7a2Vps3b9bw4cMbHZek9evXKy4uTpIUGxurDRs2qLa2ttl6eKgOAADAwgyZv7Xy8fMXFBTI6XQ2+iw4OFjBwcGNjv0wtS0qKlJYWJj7fXh4uAoLC084HhYWpsLCQpWVlSkoKEgOh6PR8R+ey+FwKCgoSKWlpTr33HObrJ+GGAAAAGdFfHy88vLyGh1LSEjQlClTmv25+vr6htGL77hcLhmG0eTx479+3w/ff/9n/PyaH4qgIQYAALAwb27dnJaWdtKE2JOIiIhGD78VFxcrPDz8hOMlJSUKDw9XaGioKioq5HQ65e/v7/6+1JAul5SUKCIiQnV1daqqqlJISEjz9f/YGwUAAACaExkZqa5duzZ6/ZiGuF+/ftq7d6/27dsnp9OptWvXKjo6Wl26dFGbNm2Uk5MjScrMzFR0dLQCAgIUFRWlrKwsSVJGRoaio6MlSUOGDFFGRoYkKSsrS1FRUQoICGj2+iTEAAAAFubNGeLT1aZNGy1atEhTpkxRTU2NhgwZohEjRkiSUlJSNHv2bFVWVqpPnz6aOHGiJCk5OVlJSUlavny5IiMjtWTJEknStGnTlJSUpJiYGHXs2FEpKSme63e5XK4zvIcWk7P3iGrq6lu6DLRCgy7qrE27y1q6DLRSr+wqaukS0IotiumppNd2tnQZaIU6t3Poget6tHQZpyzj8wJVHXN6/uIZ6BDor5sujTT1GmYiIQYAALCw01gm+LSu4cuYIQYAAICtkRADAABYmHs3OZOv4ctIiAEAAGBrJMQAAAAWZsj8BNS382ESYgAAANgcCTEAAICFMUPsGQkxAAAAbI2EGAAAwMJ8Yae6lkZCDAAAAFujIQYAAICtMTIBAABgYYa88FCdjw9NkBADAADA1kiIAQAALMxP5iegvp6w+nr9AAAAwBkhIQYAALAwNubwjIQYAAAAtkZCDAAAYGFszOEZCTEAAABsjYQYAADAygzJ9BFfH4+ISYgBAABgayTEAAAAFtawDrG5Ea6vJ6y+Xj8AAABwRkiIAQAALMzwwgyxjy9DTEIMAAAAeyMhBgAAsDDju7/MvoYvIyEGAACArdEQAwAAwNYYmQAAALAwHqrzjIQYAAAAtkZCDAAAYGF+MrywMYdvR8QkxAAAALA1EmIAAAAr88IMsY8HxCTEAAAAsDcSYgAAAAtjlQnPSIgBAABgayTEAAAAFsbWzZ6REAMAAMDWSIgBAAAszM9oeJl9DV9GQgwAAABbIyEGAACwMGaIPSMhBgAAgK2REAMAAFiYIS+sQ2zu6U1HQgwAAABboyEGAACArTEyAQAAYGE8VOcZCTEAAABsjYQYAADAwgwvbMxh9kN7ZiMhBgAAgK2REAMAAFgYM8SekRADAADA1kiIAQAALMwwvLAxh28HxDTEaP3eeO8TrV67yf2+6ttqFZeWq2+v7qqsPOo+/k1RmX5+yfl66IHbtGdfkaYn/1NHyr9Vu7aBSkq4Wed1CZMkrXsnR+mvfiCn06nLLu2hhDti5HD4e/2+AJjH5XLpzZfe0k8ifqLLB1+muto6vfvqehUeLJRLUkTXc3Vt3FA5Av73j8Evcrbrq+1faVFMT/exzz/epk//s1WGYahT52D96te/VLsO7VRxuEJvrXlb31Z9K1e9S5cNvkyXXNbb+zcK4KwwtSGurKzUrbfeqn/84x/q2rVro8927NihWbNmqaqqSlFRUZo7d64cDvpznOj6IQN0/ZABkqS6OqemJ6/UrTdFK27YFe7vfLnnoOYueUFTfxcnSfrtrH8qbtgV+uXgfvrok12au+QFPZmSoNwDRfrni+/oH3/5g4KD2mnBo6u1+rVNunXUNS1ybwDOvtKiUr376nv65uA3+knETyRJH6/frPr6esUnjJdLLr3+4hva/N4W/eJXV6n622p98OaH2rl1p7pc0MV9niOlR7TprQ81cfptate+nd57bYP+885HujZuqN5d+57O73m+Bgzqr6rKb/WvR/6lbj26qWOnoJa6baBJhszfWtnHA2LzZoi3bt2qcePGKTc396SfJyYmas6cOXr99dflcrmUnp5uVimwkBcy31fnTh0aNcO1dXX6y2Mv697f3qDwczqpuLRcu3ILde2gSyVJAwdcrKPVx7R7b4E2bdmhX1zeSyHBHeTn56fYYVforfe3ttTtADDB1o8+U5+oS3RR3wvdx7qc30VXDr1Chp8hPz8/hf00TBWHKyRJu7btVlDHDrpmxOBG53G5XKp31qu2plauepdqj9XK/7v/mhQ3Pkb9rvq5JKnicIUMPz85AvgvTYCvMq0hTk9PV3JyssLDw0/4LC8vT9XV1erfv78kafTo0crOzjarFFjEkfIqvbj2A02+fWSj4+ve+a/OCe2owVdeIkkqLjmiyLBO8vP73x/vsNBglZQeUVFJucLP6fS/4z8JVsmhcu/cAACvuDZuqHr169noWPeLzlPnczpLksrLyvXppq268LuG+edXXqqB113pbnaPC/lJiC4ffJn+tfRZPfGXlcrLzdcVQ6Ikyd1Yr37yZaU//qL6Xt5H7dq388LdAafOzzC88vJlps0ozJ8/v8nPioqKFBYW5n4fFhamwsJCs0qBRax9a4sGRfXWT88NbXR89WubdN/do9zvXS7XCcP9Lkl+fn5yuVyNj7skP7NXKwfQahTmFWnt86/p5wMv1c96XdDsd/ft3q892/doUuIdate+nTa+8YHefOkt3Tghzv2dMXeO1rdVR7Xm6Qx1zumsPpdfYvYtADBBiwzt1tfXy/hex9LQwJx6U3L5BZ08fwmWMT1nh/56/xgNuqiz+9inXx5QgJ80edQA95+h84KlP/+lXL+4MMR9rLKiSr/q31XHyg+ruKzSfY73j5To/J+GNjonrI/fb3s49NHHuuTCMP3xu4fk0rO3aHraq/p70ljdOvKKE77/rLNMa4oLJEmLYnpq+qKtuivuCv35Nw3PMOy7PEyXj5mvRTE99fKbn2jYoN7q2KGtJCm8NE+HDlc1eiAPaC2YIfasRRriiIgIFRcXu9+XlJScdLTCk5y9R1RTV382S0MrVVF5VLv3F8nVobM27S5zH38p+zP17nm+PtxzuNH3e3Q7R/P/uUHXXf1zbf50t44561WudupyQXeteDFN1103UCHBHfSXf76r/j+/qNE5YX2v7Cpq6RLgBTkHjyi31qHC13bq6y/36q01b2vUxDh9Wh+sT1/becL3t2/9RruLqiRJSa/t1FfHArRmbY7Kzj1PgW0C9d+N/1VoZLiSXtupl556Xcve+EJXDr1CNdU1eumVzbry2iuVdJLzwjo6t3Poget6tHQZlvDiiy/queeec78/ePCgRo0apaNHjyonJ0ft2jWMICUkJGjYsGFNLsaQn5+vxMREHTp0SBdccIFSUlLUoUOHU66nRRriLl26qE2bNsrJydHll1+uzMxMRUdHt0Qp8BF53xxSaEjHE5ZHO1hwSBFhISd8/58L79BtM/+ltJffU2CAQ3P+eKv8/PzUo3uEJoy5Vn+a97Tq6pzqfVFXVpgAbOD97I2Sy6W31rzjPvbT7pG6Nm5okz9zyWW9VV5Wrn8vXyV/f38Fh3TUsJuHSZKuH/0rvf3Ku3ru789LkvpG9dGFl9AooZVqhRHx2LFjNXbsWEnS7t27de+99yohIUG33367nnvuuROC0sTERD300EPq37+/Zs6cqfT0dI0fP15z587V+PHjFRMTo8cee0ypqalKTEw89fJdPxyqPMuuu+46/etf/1LXrl111113aerUqbr00kv15Zdfavbs2aqsrFSfPn20cOFCBQYGntK5SYjRlEEXdSb1RZNIiNGcRTE9SXpxUr6aEH+yr9z0fqmNw08Dugef1s/Gx8frtttu09ChQzV48GANGDBAhYWFGjZsmBISElRQUKDbb79db731liRpy5YtevTRR7Vy5UoNHDhQH3/8sRwOhwoKCnTbbbfp7bffPuUaTE+I33nnf/82/sQTT7j/vlevXlq9erXZlwcAAICXFBQUyOl0NjoWHBys4OCTN8ubNm1SdXW1Ro4cqQMHDuiqq65ScnKyOnbsqHvuuUerV6/WRRdddNLFGMrKyhQUFOTex+JMFmlgJwwAAACLM7z02Ft8fLzy8vIaHUtISNCUKVNO+v0XXnhBd9xxhySpW7dueuyxx9yfTZgwQRkZGerRo8dJF2M42aIMp7NIg0RDDAAAgLMkLS3tpAnxyRw7dkybN2/WokWLJEk7d+5Ubm6uhg8fLqmh8XU4HE0uxhAaGqqKigo5nU75+/uruLj4tBZpkEzcmAMAAAAtzzC885KkyMhIde3atdGrqYZ4586dOv/889W+fXtJDQ3wggULdOTIEdXW1mrVqlUaNmxYo8UYJLkXYwgICFBUVJSysrIkSRkZGae9SAMJMQAAALzuwIEDioiIcL/v1auX7r77bo0bN051dXW6/vrrFRsbK0lKSUlptBjDxIkTJUnJyclKSkrS8uXLFRkZqSVLlpxWLaavMmEmVplAU1hlAs1hlQk0h1Um0BRfXWVi6/5yHaszt90LdBjqd97prTLRGjAyAQAAAFtjZAIAAMDKWuHGHK0NCTEAAABsjYQYAADAwgwvrELsrXWOzUJCDAAAAFsjIQYAALCw768TbOY1fBkJMQAAAGyNhBgAAMDCWGTCMxJiAAAA2BoJMQAAgNX5eoRrMhJiAAAA2BoNMQAAAGyNkQkAAAALY2MOz0iIAQAAYGskxAAAABbGxhyekRADAADA1kiIAQAALM7HA1zTkRADAADA1kiIAQAArIy9mz0iIQYAAICtkRADAABYGOsQe0ZCDAAAAFsjIQYAALAw1iH2jIQYAAAAtkZCDAAAYGEsMuEZCTEAAABsjYQYAADAyoiIPSIhBgAAgK3REAMAAMDWGJkAAACwMDbm8IyEGAAAALZGQgwAAGBhbMzhGQkxAAAAbI2EGAAAwMJYdc0zEmIAAADYGgkxAACAlRERe0RCDAAAAFsjIQYAALAw1iH2jIQYAAAAtkZCDAAAYGVeWIfYxwNiEmIAAADYGwkxAACAhbHIhGckxAAAALA1EmIAAACr8/UI12QkxAAAALA1GmIAAADYGiMTAAAAFsbGHJ6REAMAAMDWSIgBAAAszPDCxhymb/xhMhJiAAAA2BoJMQAAgIWxMYdnJMQAAACwNRJiAAAAKyMi9oiEGAAAALZGQgwAAGBhrEPsGQkxAAAAbI2EGAAAwMJYh9gzGmIAAAB41YQJE1RaWiqHo6EVnTdvnqqqqrRw4ULV1NRo5MiR+uMf/yhJ2rFjh2bNmqWqqipFRUVp7ty5cjgcys/PV2Jiog4dOqQLLrhAKSkp6tChw2nVw8gEAACAhRleev1YLpdLubm5yszMdL969uypmTNnKjU1VVlZWdq2bZvee+89SVJiYqLmzJmj119/XS6XS+np6ZKkuXPnavz48crOzlbfvn2Vmpp62v8b0RADAADAa77++mtJ0qRJk3TjjTfqueee02effabu3burW7ducjgciouLU3Z2tvLy8lRdXa3+/ftLkkaPHq3s7GzV1tZq8+bNGj58eKPjp4uRCQAAACvz4jrEBQUFcjqdjT4KDg5WcHCw+315ebl+8Ytf6M9//rNqa2s1ceJE3XnnnQoLC3N/Jzw8XIWFhSoqKmp0PCwsTIWFhSorK1NQUJB75OL48dNFQwwAAICzIj4+Xnl5eY2OJSQkaMqUKe73AwYM0IABA9zvx4wZo0cffVSXX365+5jL5ZJhGKqvr5fxvSf2jh8//uv3/fD9qaAhBgAAwFmRlpZ20oT4+7Zs2aLa2lr94he/kNTQ5Hbp0kXFxcXu7xQXFys8PFwRERGNjpeUlCg8PFyhoaGqqKiQ0+mUv7+/+/unixliAAAAizNM/uu4yMhIde3atdHrhw1xRUWFFi9erJqaGlVWVmrNmjW67777tHfvXu3bt09Op1Nr165VdHS0unTpojZt2ignJ0eSlJmZqejoaAUEBCgqKkpZWVmSpIyMDEVHR5/2/z4kxAAAAPCaa6+9Vlu3btVNN92k+vp6jR8/XgMGDNCiRYs0ZcoU1dTUaMiQIRoxYoQkKSUlRbNnz1ZlZaX69OmjiRMnSpKSk5OVlJSk5cuXKzIyUkuWLDntmgyXy+U6K3fXAnL2HlFNXX1Ll4FWaNBFnbVpd1lLl4FW6pVdRS1dAlqxRTE9lfTazpYuA61Q53YOPXBdj5Yu45TlHa6R0+R2yd9P6hLSxtyLmIiRCQAAANgaIxMAAAAW5sVV13wWCTEAAABsjYQYAADAwgyj4WX2NXwZCTEAAABsjYQYAADA0nw8vvUCEmIAAADYGgkxAACAhTFD7BkJMQAAAGyNhBgAAMDCWIfYMxJiAAAA2BoJMQAAgIUZ8sIMsbmnNx0JMQAAAGyNhhgAAAC2xsgEAACAhRkyeKjOAxJiAAAA2BoJMQAAgJV5I7718YiYhBgAAAC2RkIMAABgcT4e4JqOhBgAAAC2RkIMAABgYYbhha2bfTyCJiEGAACArZEQAwAAWBjrEHtGQgwAAABbIyEGAACwMtYh9oiEGAAAALZGQgwAAGBhhrywyoTJ5zcbCTEAAABsjYQYAADAwliH2DMSYgAAANgaDTEAAABsjZEJAAAAC2NjDs9IiAEAAGBrJMQAAAAWxkN1npEQAwAAwNZoiAEAAGBrNMQAAACwNWaIAQAALIwZYs9IiAEAAGBrJMQAAACWZv46xL6OhBgAAAC2RkIMAABgYd6Y72WGGAAAAPBhJMQAAAAW5o3w1scDYhJiAAAA2BsJMQAAgNX5eoRrMhJiAAAA2BoJMQAAgIV5YxViXw+gSYgBAABgazTEAAAAsDVGJgAAACzMKxtzmH8JU5EQAwAAwNZIiAEAACyMjTk8IyEGAACArZEQAwAAWJmvx7deQEIMAAAAWyMhBgAAsDA25vCMhBgAAAC2RkIMAABgYaxD7JlPN8SBDkOE3GhKGwd/NnByndv59P/1wQv4M4KTCW7ru38ufL1hNZvhcrlcLV0EAAAA0FKI0AAAAGBrNMQAAACwNRpiAAAA2BoNMQAAAGyNhhgAAAC2RkMMAAAAW6MhBgAAgK3REAMAAMDWaIgBAJDEPlWAfdEQwxKqqqq0Z8+eli4DgA+rqqpq6RIAtBAaYvi80tJSTZ06VQ8//LCGDBmijRs3tnRJAHxITk6OHnroId1www16+eWXW7ocAC2Ahhg+raysTE899ZTCw8O1YsUKPfTQQ3rttdfkdDpbujQAPuDQoUPasmWLysrK1K5dOw0dOrSlSwLQAmiI4dPeffddVVdX684775Qk1dXVqaKiQv7+/swDAvDoJz/5ie655x7V1tYqLi5OoaGhkqT6+nr3d7799lsVFxe3VIkAvMDR0gUAp6uqqkq7du3SBRdcoB49ekiSKioqFBERodLSUvc/2LZv365PPvlE//3vfzV58mRdeOGFLVk2gFbC5XLJMAzt2bNH27dv14wZM9yfGYYhSXriiSe0d+9e/ec//9HVV1+t//u//1NISEgLVQzALCTE8FlHjx5Vfn6+Lr30UknSvn37tHPnToWGhrqb4SNHjighIUGS1Lt3b82ePVu7du1qsZoBtB7H/yvS448/rqFDhyoyMtL9mWEY2rFjh9LS0jRx4kS98847OnLkiLZv395S5QIwEQkxfFZ5ebm+/vpr/fznP5ckbdmyReXl5YqNjZUkVVZW6tlnn1Xfvn0VHx8vScrNzdWhQ4darGYArYPL5ZKfn5+++eYbbd26VampqZIaRiX8/Px0+PBhvfTSSxo5cqR69eql+vp6XXzxxdq3b58GDRrUwtUDONtIiOGzwsPD1atXLz344IN65plnlJGRoejoaPXu3VuSlJ+fr5ycHE2aNEmSVFNTo44dO+rrr79uybIBtALHRyKefPJJnX/++e6xKz+/hn8sfvPNN9q+fbvGjRsnqaGBLioqci/NxjMKgLXQEMNnBQUFafbs2QoMDFRhYaHmzp2rfv36uT/fsmWL2rZtq/79+0uSDh8+rI0bN2rAgAEtVDGA1mbatGn6f//v/0mSnn32WeXn50uS3nnnHZ1zzjk677zzJEl79+7VRx995P4vUMcbagDWwMgEfFpISIgeeOABSQ0rTEydOlV/+MMf1LdvX61bt05xcXGSpGPHjumVV15RZGSkLrnkEvfDNADsrWPHjurYsaMkqV27dqqoqJDUkBBfc801khrWOn/ppZcUFRWliIgI91gFAOugIYZlOBwOpaam6tixY5KkESNGqLKyUpL01ltv6T//+Y9+//vft2SJAFqxMWPGuP8+JiZGS5YsUVBQkD755BMVFxfrvvvuk0Q6DFiR4WIQCha1e/duzZ49W3V1derRo4cGDx6sG2+8saXLAuAjsrKytG7dOvXr10/XX3+9e3wCgPXQEMPyvvzyS5177rnq3LmzJDEuAQAAGqEhhi3QBAMAgKbwVABsgWYYAAA0hYYYAAAAtkZDDAAAAFujIQYAAICt0RADAADA1miIAZx1Bw8eVO/evTVq1Cj368Ybb9Tq1avP+Nz33HOPXn75ZUnSqFGjVF5e3uR3KyoqNHHixFO+RnZ2tiZMmHDC8e9v3ducnj17qrS09JSumZSUpJUrV57SzwAAzg52qgNgirZt2yozM9P9vrCwULGxserbt6969ep1Vq7x/fOfzJEjR/T555+flWsBAKyLhhiAV5x77rnq3r27cnNztX37dq1evVpHjx5VUFCQnn32Wb344ov697//rfr6eoWEhOjPf/6zevToocLCQiUlJamoqEg//elPdejQIfc5e/bsqQ8//FChoaFasWKF1qxZI4fDoe7du2vRokWaMWOGqqurNWrUKL388svKzc3V/PnzdfjwYTmdTk2YMMG9Xe/f/vY3vfrqqwoJCVH37t093s/evXs1b948VVVVqbi4WL169dLSpUvVpk0bSdLSpUv1+eefq76+XtOnT9e1114rSU3eJwCg5dAQA/CKTz75RPv371e/fv304Ycfas+ePXrnnXcUFBSkjz/+WBkZGUpLS1O7du20ceNGJSQkaN26dZo3b5769eun6dOna9++fbrppptOOPfbb7+tl19+Wenp6erUqZMWLlyo5557TgsXLlRcXJwyMzNVV1enqVOnavHixerTp48qKir0m9/8RhdeeKFKSkr0xhtvKCMjQ23bttW9997r8X7S09N10003adSoUaqtrdXo0aO1fv16DR8+XJLUtWtXzZs3T7t27dKECRO0bt067dmzp8n7BAC0HBpiAKY4nsxKktPpVOfOnfXwww8rMjJSUkO6GxQUJElav3699u3bp1tvvdX98+Xl5Tp8+LA2bdqkBx54QJLUvXt3DRw48IRrffjhhxoxYoQ6deokSZoxY4akhlnm43Jzc7V//37NnDmzUY3bt2/XV199pWHDhrnrufnmm/Xss882e3+JiYn64IMP9MQTTyg3N1dFRUX69ttv3Z+PGzdOknTxxRerR48e+uSTT5STk9PkfQIAWg4NMQBT/HCG+Ifat2/v/vv6+nqNGjVKiYmJ7vdFRUXq1KmTDMPQ93eYdzhO/L8tf3//RrsRlpeXn/CwndPpVMeOHRvVVFJSoo4dO2rx4sWNruHv7+/x/u677z45nU6NHDlSQ4cOVUFBQaNz+Pn975nl+vp6ORyOZu8TANByWGUCQIsbPHiwXnvtNRUVFUmS/v3vf+v222+XJF1zzTVatWqVJCk/P18fffTRCT8/aNAgvfnmm6qsrJQk/f3vf9czzzwjh8Mhp9Mpl8ulCy64oFGTXlBQoNjYWG3btk3R0dHKzs5WeXm56uvrPT6sJ0kbN27UvffeqxtuuEGStHXrVjmdTvfna9askSR98cUX7lGR5u4TANBySIgBtLjBgwfrrrvu0qRJk2QYhoKCgrRs2TIZhqHk5GTNmDFDI0eOVERExElXqBgyZIj27NnjHlO48MIL9eCDD6pdu3b6+c9/rpiYGKWlpSk1NVXz58/Xk08+qbq6Ok2bNk2XX365JGnnzp26+eabFRwcrF69eqmsrKzZmv/4xz/q3nvvVfv27RUUFKQrrrhC+/fvd39+4MAB3XTTTTIMQ0uWLFFISEiz9wkAaDmG6/v/jQ8AAACwGUYmAAAAYGs0xAAAALA1GmIAAADYGg0xAAAAbI2GGAAAALZGQwwAAABboyEGAACArdEQAwAAwNb+PyUxPPje4sWvAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1152x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# model = MultinomialNB(alpha=.05)\n",
    "# model.fit(X_train, y_train)\n",
    "\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "accuracy = model.score(X_test, y_test)\n",
    "\n",
    "print(\"Model Accuracy: %f\" % accuracy)\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16, 10))\n",
    "\n",
    "disp = plot_confusion_matrix(model, X_test, y_test,\n",
    "                             display_labels=model.classes_,\n",
    "                             cmap=plt.cm.Blues, ax=ax)\n",
    "\n",
    "plt.xticks(rotation=-25)\n",
    "disp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello, my name is kukai and do you want to talk about the one and only god, thighs\n",
      "0.0 0.545\n",
      "1.0 0.455\n",
      "meh, indecisive?\n",
      "I hate you you should delete your twitter account\n",
      "0.0 0.813\n",
      "1.0 0.187\n",
      "REJECT\n",
      "thanks for the recent support.  :)\n",
      "0.0 0.288\n",
      "1.0 0.712\n",
      "ACCEPT\n",
      "imagine being called a CONTENT CREATOR with people donating $5 for everything\n",
      "0.0 0.426\n",
      "1.0 0.574\n",
      "meh, indecisive?\n",
      "cafeteria has new good fries\n",
      "0.0 0.593\n",
      "1.0 0.407\n",
      "meh, indecisive?\n",
      " I hate the new cafeteria french fries\n",
      "0.0 0.749\n",
      "1.0 0.251\n",
      "REJECT\n",
      "fuck\n",
      "0.0 0.554\n",
      "1.0 0.446\n",
      "meh, indecisive?\n"
     ]
    }
   ],
   "source": [
    "my_sentences = [\n",
    "\"\"\"hello, my name is kukai and do you want to talk about the one and only god, thighs\"\"\",\n",
    "\"\"\"I hate you you should delete your twitter account\"\"\",\n",
    "\"\"\"thanks for the recent support.  :)\"\"\",\n",
    "\"\"\"imagine being called a CONTENT CREATOR with people donating $5 for everything\"\"\",\n",
    "\"cafeteria has new good fries\",\n",
    "\" I hate the new cafeteria french fries\",\n",
    "\"fuck\"\n",
    "]\n",
    "\n",
    "for sentence in my_sentences:\n",
    "    print(sentence)\n",
    "    # 1. Apply the text pipeline to your sentence\n",
    "    input_text = text_pipeline2(sentence)\n",
    "    # 2. Transform your cleaned text using the `X = vectorizer.transform([your_text])`\\\n",
    "    input_vec = vectorizer.transform([input_text])\n",
    "    # 3. Use the model to predict your new `X`. \n",
    "    model.predict(input_vec)\n",
    "    # 4. Print the prediction\n",
    "    pp = model.predict_proba(input_vec)\n",
    "    p_val = []\n",
    "    for c, p in zip(model.classes_, pp.round(3)[0]):\n",
    "        p_val.append(p)\n",
    "        print(c, p)\n",
    "    if p_val[0] > 0.65:\n",
    "        print(\"REJECT\")\n",
    "    elif p_val[1] > 0.65:\n",
    "        print(\"ACCEPT\")\n",
    "    else:print(\"meh, indecisive?\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n"
     ]
    }
   ],
   "source": [
    "#X is the input\n",
    "\n",
    "counter = 0\n",
    "threshold = 100\n",
    "\n",
    "good_dict = dict()\n",
    "bad_dict = dict()\n",
    "indecisive_dict = dict()\n",
    "\n",
    "good_counter = 0\n",
    "bad_counter = 0\n",
    "indecisive_counter = 0\n",
    "\n",
    "good_examples = []\n",
    "bad_examples = []\n",
    "indecisive_examples = []\n",
    "\n",
    "dataset =  df[\"clean_comment2\"].values\n",
    "\n",
    "for sentence in dataset:\n",
    "    counter +=1\n",
    "    if counter > threshold:\n",
    "        break\n",
    "    #print(sentence)\n",
    "    # 1. Apply the text pipeline to your sentence\n",
    "    input_text = text_pipeline2(sentence)\n",
    "    # 2. Transform your cleaned text using the `X = vectorizer.transform([your_text])`\\\n",
    "    input_vec = vectorizer.transform([input_text])\n",
    "    # 3. Use the model to predict your new `X`. \n",
    "    model.predict(input_vec)\n",
    "    # 4. Print the prediction\n",
    "    pp = model.predict_proba(input_vec)\n",
    "    p_val = []\n",
    "    for c, p in zip(model.classes_, pp.round(3)[0]):\n",
    "        p_val.append(p)\n",
    "        #print(c, p)\n",
    "    if p_val[0] > 0.65:\n",
    "        #print(\"REJECT\")\n",
    "        bad_counter+=1\n",
    "        if bad_counter < 100:\n",
    "            bad_examples.append(sentence)\n",
    "        for word in sentence.split():\n",
    "            bad_dict[word] = bad_dict.get(word, 0) + 1\n",
    "        \n",
    "    elif p_val[1] > 0.65:\n",
    "        #print(\"ACCEPT\")\n",
    "        good_counter+=1\n",
    "        if good_counter < 100:\n",
    "            good_examples.append(sentence)\n",
    "        for word in sentence.split():\n",
    "            good_dict[word] = good_dict.get(word, 0) + 1\n",
    "    else:\n",
    "        #print(\"meh, indecisive?\")\n",
    "        indecisive_counter+=1\n",
    "        if indecisive_counter < 100:\n",
    "            indecisive_examples.append(sentence)\n",
    "        for word in sentence.split():\n",
    "            indecisive_dict[word] = indecisive_dict.get(word, 0) + 1\n",
    "\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dear going difficult keep discussion modi page many glorious commentaries happening mainstream media status improvement gujarat true gujaratis mostly vegetarian spoke guy gurgaon douchey type relocating gujarat mentioned kinda different uncomfortable haryana gujaratis feel state guys gujarati manoos movements\n",
      "********************\n",
      "lets talk elephant room regardless media wants think good bad equation hindu muslims gujrat good worsened improved since\n",
      "********************\n",
      "many flavours buddhism pure land ideas common however important thing realize really matter big difference compared abrahamic religions buddhism dogmatic sense bunch things must taken literally else non believer sinner whatever maybe pure land ideas work great maybe great works works work useless historical buddha taught dramatically different styles suit audience parables metaphors point take literally believing literally physically true zen koans good example purely distilled form stories stories believe physically happened reading history book entirely irrelevant story point wondering really happen place really exist missing point also worth noting things psychological phenomenon physical phenomenon personally find makes buddhist cosmology much easier understand considering competitor physical cosmology conflict different cosmos\n",
      "********************\n",
      "sabarmati waterfront really good maintained properly autorickshaws like cram people max people inside arent safety regulations regarding\n",
      "********************\n",
      "must transitioning new avatar\n",
      "********************\n"
     ]
    }
   ],
   "source": [
    "examples = random.sample(good_examples, 5)\n",
    "\n",
    "for texts in examples:\n",
    "    print(texts)\n",
    "    print( \"*\"*20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "please downvote thread comments interest state leave alone complaining politics please something constructive ask talk state people instead leaving one liner modi messages\n",
      "********************\n",
      "geez every single post thread downvoted\n",
      "********************\n",
      "impress gujju girl begin\n",
      "********************\n",
      "sit together watch simpsons episode lisa becomes buddhist simpsons season episode little faith discuss\n",
      "********************\n",
      "homebrew setting primary lawful evil deity named friend lewie essentially three domains tyranny law applied without mercy vengeance community idea cruel harsh god also recognizes catch flies honey vinegar thus church often benevolent toward common people day day basis running gag lewian churches sponsor inner city basketball teams major faith probably want change name might make interesting dynamic within setting\n",
      "********************\n"
     ]
    }
   ],
   "source": [
    "examples = random.sample(bad_examples, 5)\n",
    "\n",
    "for texts in examples:\n",
    "    print(texts)\n",
    "    print( \"*\"*20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "technically could argue sobek evil would represent power also crocodiles whereas also represents fertile land also guy could shapeshift crocodile badass\n",
      "********************\n",
      "supposed swap tso branch order basically switch immediately entering crypt clear crypt max tso piety holy brand best weapon case executioners axe post endgame branch order like whatever theres strict order like early game whichever branch feel best prepared avoid meeting terrible fate hands trog wrath book blink soon leave trog train transloc little bit cast whenever surrounds berserking enemies blink middle run staircase teleport keep scrolls blinking hand purpose feel secure also spell trog wrath includes fire miscasts burn shit see trick going lair rat block still viable rat shield thing combos tedious unnecessary case minotaur retaliatory headbutt would kill rat anyway option antimagic axe carry around viable use since strictly one handed train shields use since shield reflection could use really war axes arent good fantastic selection resists little damage practical choice weapon tough monster wouldnt forgo damage output weapon use physical shield shields arent good melee allruners therse always tsos divine shield ability want reflection isnt good shield brand plus double good tso worshiper reflect poison projectile hits something incur penance use poison\n",
      "********************\n",
      "many big companies gujarat\n",
      "********************\n",
      "know surely statue every bjp ruled state half schemes named couple airports guy like savarkar compared modi small fry\n",
      "********************\n",
      "zarus\n",
      "********************\n"
     ]
    }
   ],
   "source": [
    "examples = random.sample(indecisive_examples, 5)\n",
    "\n",
    "for texts in examples:\n",
    "    print(texts)\n",
    "    print( \"*\"*20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "# of words 1317\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('way', 10),\n",
       " ('god', 10),\n",
       " ('something', 10),\n",
       " ('time', 11),\n",
       " ('like', 11),\n",
       " ('jesus', 11),\n",
       " ('different', 11),\n",
       " ('may', 12),\n",
       " ('really', 12),\n",
       " ('also', 13),\n",
       " ('trog', 13),\n",
       " ('mind', 14),\n",
       " ('things', 15),\n",
       " ('good', 15),\n",
       " ('people', 16),\n",
       " ('buddhism', 19),\n",
       " ('buddha', 19),\n",
       " ('one', 21),\n",
       " ('pure', 25),\n",
       " ('land', 29)]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# finding the most frequent words\n",
    "\n",
    "sorted_good = sorted(good_dict.items(), key=lambda kv: kv[1])\n",
    "print(type(sorted_good))\n",
    "print(\"# of words\", len(good_dict))\n",
    "sorted_good[-20:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Most Frequent Words in Good Comments'}, xlabel='Frequency', ylabel='Common_Good_Words'>"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df = pd.DataFrame(sorted_good[-20:], columns = ['Common_Good_Words', 'Frequency'])\n",
    "# df.head()\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12,8))\n",
    "\n",
    "sns.set_color_codes(\"bright\")\n",
    "goodplot = sns.barplot(x=\"Frequency\", y=\"Common_Good_Words\", data=df,\n",
    "             color=\"b\", )\n",
    "goodplot.set_title(\"Most Frequent Words in Good Comments\")\n",
    "\n",
    "goodplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# of words 347\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('day', 3),\n",
       " ('tso', 3),\n",
       " ('branch', 3),\n",
       " ('order', 3),\n",
       " ('weapon', 3),\n",
       " ('trog', 3),\n",
       " ('rat', 3),\n",
       " ('state', 3),\n",
       " ('modi', 3),\n",
       " ('daaru', 3),\n",
       " ('also', 4),\n",
       " ('suffering', 4),\n",
       " ('like', 4),\n",
       " ('good', 4),\n",
       " ('evil', 5),\n",
       " ('god', 5),\n",
       " ('get', 5),\n",
       " ('shield', 5),\n",
       " ('use', 5),\n",
       " ('gujarat', 6)]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_med = sorted(indecisive_dict.items(), key=lambda kv: kv[1])\n",
    "print(\"# of words\", len(indecisive_dict))\n",
    "sorted_med[-20:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Most Frequent Words in Indecisive Comments'}, xlabel='Frequency', ylabel='Common_Mid_Words'>"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Creating the barplot for middile words\n",
    "\n",
    "df = pd.DataFrame(sorted_med[-20:], columns = ['Common_Mid_Words', 'Frequency'])\n",
    "# df.head()\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12,8))\n",
    "\n",
    "sns.set_color_codes(\"muted\")\n",
    "midplot = sns.barplot(x=\"Frequency\", y=\"Common_Mid_Words\", data=df,\n",
    "             color=\"g\", )\n",
    "midplot.set_title(\"Most Frequent Words in Indecisive Comments\")\n",
    "\n",
    "midplot\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# of words 525\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[('much', 3),\n",
       " ('modi', 3),\n",
       " ('worst', 3),\n",
       " ('part', 3),\n",
       " ('least', 3),\n",
       " ('biggest', 3),\n",
       " ('know', 3),\n",
       " ('state', 3),\n",
       " ('crazy', 3),\n",
       " ('like', 4),\n",
       " ('food', 4),\n",
       " ('walsh', 4),\n",
       " ('even', 4),\n",
       " ('want', 5),\n",
       " ('party', 5),\n",
       " ('gujarat', 5),\n",
       " ('evil', 6),\n",
       " ('got', 6),\n",
       " ('one', 7),\n",
       " ('god', 9)]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_bad = sorted(bad_dict.items(), key=lambda kv: kv[1])\n",
    "print(\"# of words\", len(bad_dict))\n",
    "sorted_bad[-20:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:title={'center':'Most Frequent Words in Bad Comments'}, xlabel='Frequency', ylabel='Common_Bad_Words'>"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Creating a bar plot for the sorted_bad words\n",
    "df = pd.DataFrame(sorted_bad[-20:], columns = ['Common_Bad_Words', 'Frequency'])\n",
    "# df.head()\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(12,8))\n",
    "\n",
    "sns.set_color_codes(\"dark\")\n",
    "badplot = sns.barplot(x=\"Frequency\", y=\"Common_Bad_Words\", data=df,\n",
    "             color=\"r\", )\n",
    "badplot.set_title(\"Most Frequent Words in Bad Comments\")\n",
    "\n",
    "badplot"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}