8-Sensitive-Bot.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Save2Drive](https://raw.githubusercontent.com/alahnala/AI4All2020-Michigan-NLP/master/slides/save2drive.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Run cell below to get setup\n",
    "\n",
    "### Credit: NRC Emotion and Sentiment Lexicons\n",
    "We are obtaining lexicons created by Saif Mohammed et al. See  [Sentiment and Emotion Lexicons](http://saifmohammad.com/WebPages/lexicons.html) and [Terms of Use](http://saifmohammad.com/WebPages/lexicons.html#terms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, sys\n",
    "import pandas as pd\n",
    "!python3 -m pip install wget\n",
    "import wget \n",
    "IN_COLAB = 'google.colab' in sys.modules\n",
    "\n",
    "# Download NRC lexicons\n",
    "NRC_Emotion_Lexicon_Path = 'NRC-Sentiment-Emotion-Lexicons/NRC-Emotion-Lexicon-v0.92/NRC-Emotion-Lexicon-Senselevel-v0.92.txt'\n",
    "if not os.path.isfile(NRC_Emotion_Lexicon_Path):\n",
    "    print(\"=== Downloading NRC Lexicons ===\")\n",
    "    !wget http://sentiment.nrc.ca/lexicons-for-research/NRC-Sentiment-Emotion-Lexicons.zip\n",
    "    !unzip NRC-Sentiment-Emotion-Lexicons.zip\n",
    "\n",
    "print(\"=== Getting utils from git repo ===\")\n",
    "if IN_COLAB:\n",
    "  !rm -r AI4All2020-Michigan-NLP\n",
    "  !git clone https://github.com/alahnala/AI4All2020-Michigan-NLP.git\n",
    "  !cp -r AI4All2020-Michigan-NLP/utils/ .\n",
    "  !cp -r AI4All2020-Michigan-NLP/Data/ .\n",
    "  !cp -r AI4All2020-Michigan-NLP/slides/ .\n",
    "  !cp -r AI4All2020-Michigan-NLP/Experiment-Report-Templates/ .\n",
    "  !echo \"=== Files Copied ===\"\n",
    "\n",
    "# Helpers\n",
    "print(\"=== Importing helper functions ===\")\n",
    "from nltk.stem.snowball import PorterStemmer\n",
    "from utils.nlp_basics import *\n",
    "from utils.syllable import *\n",
    "from utils.sentiment_analysis_helpers import *\n",
    "\n",
    "\n",
    "# general\n",
    "print(\"=== Importing helper functions ===\")\n",
    "from tqdm import tqdm\n",
    "import regex as re\n",
    "import pandas as pd\n",
    "from collections import Counter\n",
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "# Adding colors\n",
    "# from matplotlib import cm\n",
    "# cs=cm.Set1(np.arange(40)/40.)\n",
    "matplotlib.rcParams.update({\n",
    "    'font.family': 'serif',\n",
    "})\n",
    "plt.rcParams['font.size'] = 18\n",
    "from collections import defaultdict\n",
    "\n",
    "# preprocess functions\n",
    "print(\"=== Importing natural language toolkit and spacy ===\")\n",
    "import nltk\n",
    "nltk.download('punkt')\n",
    "from nltk.tokenize import word_tokenize\n",
    "import spacy\n",
    "nlp = spacy.load(\"en_core_web_sm\", disable=['parser', 'ner'])\n",
    "\n",
    "print(\"=== Loading NRC Lexicons to Dataframe ===\")\n",
    "SenseLevel_Emotion_Lexicon = load_senselevel_emotion_lexicon()\n",
    "Color_Lexicon = load_colors()\n",
    "print('=== Done ===')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Emotion Lexicon\n",
    "\n",
    "- During setup, we loaded the NRC Word-sense level emotion lexicon (created by Saif Mohammed)\n",
    "- It contains a term, one to three synonyms for the term, and columns for the Affect categories (anger, fear, anticipation, trust, surprise, sadness, joy, and disgust) and for polarities (negative or positive)\n",
    "- The affect and polarity columns indicate if the term has an association with affect category or polarity with **`True`** if so, and **`False`** if not\n",
    "- ***Run the cell below to observe the data frame with the lexicon***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SenseLevel_Emotion_Lexicon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Find out colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Color_Lexicon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "get_term_rows('motive', Color_Lexicon)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create a message and process to tokens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "message = \"I'm good, how are you?\"\n",
    "\n",
    "def preprocess(message):\n",
    "    tokens = word_tokenize(message.lower())\n",
    "    return tokens\n",
    "\n",
    "tokens = preprocess(message)\n",
    "tokens"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Which words from our message are in the Lexicon?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the set of terms in the lexicon\n",
    "Lexicon_Terms = set(SenseLevel_Emotion_Lexicon['term'].values)\n",
    "\n",
    "# Save the tokens list as a set in Tokens_Set\n",
    "Tokens_Set = set(tokens)\n",
    "\n",
    "# Show the intersection of these sets\n",
    "Lexicon_Terms.intersection(Tokens_Set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make 'pie slices' for Affects and Polarities\n",
    "\n",
    "- We are going to make a pie chart to show the proportion of each affect and of each polarity in this message. \n",
    "- The cell below prints out the list of Affects and Polarities for demonstration, and the cell after that creates lists needed for making the pie charts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Affects list:\", Affects)\n",
    "print(\"Polarities list:\", Polarities)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What's happening in the cell below:\n",
    "1. Initialize lists, one the sizes of `Affects` and one the size of `Polarities`\n",
    "2. Iterate through tokens\n",
    "    1. If token is not in SenseLevel_Emotion_Lexicon, continue to next token. Otherwise...\n",
    "    2. Get the entries in the Lexicon for the token\n",
    "    3. For each affect, we count the number of entries that are True for that term and affect\n",
    "        1. We add the number of Trues to the affect_pie_slices list at the position of the same affect in the Affects list\n",
    "    4. For each Polarity (negative, positive), we count the number of entries that are True for that term and polarity\n",
    "        1. We add the number of Trues to the polarity_pie_slices list at the position of the same polarity in the Polarities list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize lists\n",
    "affect_pie_slices = [0] * len(Affects)\n",
    "polarity_pie_slices = [0] * len(Polarities)\n",
    "\n",
    "# Iterate through each tokens\n",
    "for token in tokens:\n",
    "    \n",
    "    # If token is not in SenseLevel_Emotion_Lexicon, continue to next token. Otherwise...\n",
    "    if token in SenseLevel_Emotion_Lexicon['term'].values:\n",
    "        \n",
    "        # Get the entries in the Lexicon for the token\n",
    "        term_rows = get_term_rows(token, SenseLevel_Emotion_Lexicon)\n",
    "        \n",
    "        # For each affect, we count the number of entries that are True for that term and affect\n",
    "        for i, affect in enumerate(Affects):\n",
    "            affect_counter = Counter(term_rows[affect].values)\n",
    "            true_count = affect_counter[True]\n",
    "            \n",
    "            # We add the number of Trues to the affect_pie_slices list at the position of the same affect in the Affects list\n",
    "            affect_pie_slices[i] += true_count\n",
    "        \n",
    "        # For each Polarity (negative, positive), we count the number of entries that are True for that term and polarity\n",
    "        for i, pol in enumerate(Polarities):\n",
    "            pol_counter = Counter(term_rows[pol].values)\n",
    "            true_count = pol_counter[True]\n",
    "            \n",
    "            # We add the number of Trues to the polarity_pie_slices list at the position of the same polarity in the Polarities list\n",
    "            polarity_pie_slices[i] += true_count\n",
    "\n",
    "            \n",
    "print('Affect Pie Slices:', affect_pie_slices)\n",
    "print('Polarity Pie Slices:', polarity_pie_slices)            \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create our Pie Charts using the pie slices\n",
    "\n",
    "The pie charts help us visualize the potential emotions in our text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize Figure with 1 row and 2 columns of plots\n",
    "fig, axs = plt.subplots(1, 2, figsize=(15, 5), sharey=False) \n",
    "\n",
    "\n",
    "# Make Pie Chart for Affects:\n",
    "labels_1 = [affect for slice_, affect in zip(affect_pie_slices, Affects) if slice_ > 0]\n",
    "sizes_1 = [slice_ for slice_, affect in zip(affect_pie_slices, Affects) if slice_ > 0]\n",
    "axs[0].pie(sizes_1, labels=labels_1, autopct='%1.1f%%',\n",
    "        shadow=True, startangle=90)\n",
    "axs[0].axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\n",
    "\n",
    "\n",
    "# Make Pie Chart for Polarities:\n",
    "labels_2 = [affect for slice_, affect in zip(polarity_pie_slices, Polarities) if slice_ > 0]\n",
    "sizes_2 = [slice_ for slice_, affect in zip(polarity_pie_slices, Polarities) if slice_ > 0]\n",
    "\n",
    "axs[1].pie(sizes_2, labels=labels_2, autopct='%1.1f%%',\n",
    "        shadow=True, startangle=90)\n",
    "axs[1].axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Get a larger sample of data\n",
    "\n",
    "- Here we are obtaining text from two wikipedia pages, Gardening and Horticulture, to compare the Affects and Polarities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get training data from same pages of more languages\n",
    "import requests\n",
    "\n",
    "pages = ['https://en.wikipedia.org/wiki/Gardening', 'https://en.wikipedia.org/wiki/Horticulture']\n",
    "wikipedia_text = {}\n",
    "\n",
    "for page in pages:\n",
    "    title = page.split('/')[-1]\n",
    "    prefix = page.split('/wiki/')[0]\n",
    "    link = prefix + '/w/api.php'\n",
    "    response = requests.get(link,params={'action': 'query','format': 'json','titles': title,'prop': 'extracts','explaintext': True,}).json()\n",
    "    response_page = next(iter(response['query']['pages'].values()))\n",
    "    text = response_page['extract']\n",
    "    wikipedia_text[title] = text\n",
    "\n",
    "print('Gardening:', wikipedia_text['Gardening'][:100], end='...\\n')\n",
    "print('Horticulture:', wikipedia_text['Horticulture'][:100], end='...\\n')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make a Pie Chart for Gardening\n",
    "- Refer to the steps we took above on our message \"I'm good, how are you?\" to create the pie charts for the Gardening text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Gardening_Text = wikipedia_text['Gardening']\n",
    "\n",
    "def preprocess(message):\n",
    "    tokens = word_tokenize(message.lower())\n",
    "    return tokens\n",
    "\n",
    "tokens = preprocess(Gardening_Text)\n",
    "\n",
    "# Initialize lists\n",
    "affect_pie_slices = [0] * len(Affects)\n",
    "polarity_pie_slices = [0] * len(Polarities)\n",
    "\n",
    "# Iterate through each tokens\n",
    "for token in tokens:\n",
    "    \n",
    "    # If token is not in SenseLevel_Emotion_Lexicon, continue to next token. Otherwise...\n",
    "    if token in SenseLevel_Emotion_Lexicon['term'].values:\n",
    "        \n",
    "        # Get the entries in the Lexicon for the token\n",
    "        term_rows = get_term_rows(token, SenseLevel_Emotion_Lexicon)\n",
    "        \n",
    "        # For each affect, we count the number of entries that are True for that term and affect\n",
    "        for i, affect in enumerate(Affects):\n",
    "            affect_counter = Counter(term_rows[affect].values)\n",
    "            true_count = affect_counter[True]\n",
    "            \n",
    "            # We add the number of Trues to the affect_pie_slices list at the position of the same affect in the Affects list\n",
    "            affect_pie_slices[i] += true_count\n",
    "        \n",
    "        # For each Polarity (negative, positive), we count the number of entries that are True for that term and polarity\n",
    "        for i, pol in enumerate(Polarities):\n",
    "            pol_counter = Counter(term_rows[pol].values)\n",
    "            true_count = pol_counter[True]\n",
    "            \n",
    "            # We add the number of Trues to the polarity_pie_slices list at the position of the same polarity in the Polarities list\n",
    "            polarity_pie_slices[i] += true_count\n",
    "\n",
    "            \n",
    "print('Affect Pie Slices:', affect_pie_slices)\n",
    "print('Polarity Pie Slices:', polarity_pie_slices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize Figure with 1 row and 2 columns of plots\n",
    "fig, axs = plt.subplots(1, 2, figsize=(15, 5), sharey=False) \n",
    "\n",
    "\n",
    "# Make Pie Chart for Affects:\n",
    "labels_1 = [affect for slice_, affect in zip(affect_pie_slices, Affects) if slice_ > 0]\n",
    "sizes_1 = [slice_ for slice_, affect in zip(affect_pie_slices, Affects) if slice_ > 0]\n",
    "axs[0].pie(sizes_1, labels=labels_1, autopct='%1.1f%%',\n",
    "        shadow=True, startangle=90)\n",
    "axs[0].axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\n",
    "\n",
    "\n",
    "# Make Pie Chart for Polarities:\n",
    "labels_2 = [affect for slice_, affect in zip(polarity_pie_slices, Polarities) if slice_ > 0]\n",
    "sizes_2 = [slice_ for slice_, affect in zip(polarity_pie_slices, Polarities) if slice_ > 0]\n",
    "\n",
    "axs[1].pie(sizes_2, labels=labels_2, autopct='%1.1f%%',\n",
    "        shadow=True, startangle=90)\n",
    "axs[1].axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Make a Pie Chart for Horticulture\n",
    "- Similarly, create the pie charts for the Horticulture text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Horticulture_Text = wikipedia_text['Horticulture']\n",
    "\n",
    "def preprocess(message):\n",
    "    tokens = word_tokenize(message.lower())\n",
    "    return tokens\n",
    "\n",
    "tokens = preprocess(Horticulture_Text)\n",
    "\n",
    "# Initialize lists\n",
    "affect_pie_slices = [0] * len(Affects)\n",
    "polarity_pie_slices = [0] * len(Polarities)\n",
    "\n",
    "# Iterate through each tokens\n",
    "for token in tokens:\n",
    "    \n",
    "    # If token is not in SenseLevel_Emotion_Lexicon, continue to next token. Otherwise...\n",
    "    if token in SenseLevel_Emotion_Lexicon['term'].values:\n",
    "        \n",
    "        # Get the entries in the Lexicon for the token\n",
    "        term_rows = get_term_rows(token, SenseLevel_Emotion_Lexicon)\n",
    "        \n",
    "        # For each affect, we count the number of entries that are True for that term and affect\n",
    "        for i, affect in enumerate(Affects):\n",
    "            affect_counter = Counter(term_rows[affect].values)\n",
    "            true_count = affect_counter[True]\n",
    "            \n",
    "            # We add the number of Trues to the affect_pie_slices list at the position of the same affect in the Affects list\n",
    "            affect_pie_slices[i] += true_count\n",
    "        \n",
    "        # For each Polarity (negative, positive), we count the number of entries that are True for that term and polarity\n",
    "        for i, pol in enumerate(Polarities):\n",
    "            pol_counter = Counter(term_rows[pol].values)\n",
    "            true_count = pol_counter[True]\n",
    "            \n",
    "            # We add the number of Trues to the polarity_pie_slices list at the position of the same polarity in the Polarities list\n",
    "            polarity_pie_slices[i] += true_count\n",
    "\n",
    "            \n",
    "print('Affect Pie Slices:', affect_pie_slices)\n",
    "print('Polarity Pie Slices:', polarity_pie_slices)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize Figure with 1 row and 2 columns of plots\n",
    "fig, axs = plt.subplots(1, 2, figsize=(15, 5), sharey=False) \n",
    "\n",
    "\n",
    "# Make Pie Chart for Affects:\n",
    "labels_1 = [affect for slice_, affect in zip(affect_pie_slices, Affects) if slice_ > 0]\n",
    "sizes_1 = [slice_ for slice_, affect in zip(affect_pie_slices, Affects) if slice_ > 0]\n",
    "axs[0].pie(sizes_1, labels=labels_1, autopct='%1.1f%%',\n",
    "        shadow=True, startangle=90)\n",
    "axs[0].axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\n",
    "\n",
    "\n",
    "# Make Pie Chart for Polarities:\n",
    "labels_2 = [affect for slice_, affect in zip(polarity_pie_slices, Polarities) if slice_ > 0]\n",
    "sizes_2 = [slice_ for slice_, affect in zip(polarity_pie_slices, Polarities) if slice_ > 0]\n",
    "\n",
    "axs[1].pie(sizes_2, labels=labels_2, autopct='%1.1f%%',\n",
    "        shadow=True, startangle=90)\n",
    "axs[1].axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle.\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# In the next few cells, we will practice making a rule-based Chatbot that responds to the emotions in a user's message\n",
    "\n",
    "The code from Chatbot-Starter.ipynb is included - open in Colab for reference.\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/alahnala/AI4All2020-Michigan-NLP/blob/master/Chatbot-Starter.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Walk through the code below to understand the `get_affects_and_polarities`\n",
    "\n",
    "Run the cell and observe its output. Notice that the code is based off of the code we used earlier to generate the pie slices. Code often ends up coming in handy in multiple places!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess(message):\n",
    "    tokens = word_tokenize(message.lower())\n",
    "    return tokens\n",
    "\n",
    "\n",
    "def get_affects_and_polarities(message):\n",
    "\n",
    "    # get message tokens\n",
    "    tokens = preprocess(message)\n",
    "\n",
    "    # Initialize dictionaries\n",
    "    present_affects = {affect:0 for affect in Affects}\n",
    "    present_polarities = {pol:0 for pol in Polarities}\n",
    "    \n",
    "    \n",
    "    # Iterate through each tokens\n",
    "    for token in tokens:\n",
    "\n",
    "        # If token is not in SenseLevel_Emotion_Lexicon, continue to next token. Otherwise...\n",
    "        if token in SenseLevel_Emotion_Lexicon['term'].values:\n",
    "\n",
    "            # Get the entries in the Lexicon for the token\n",
    "            term_rows = get_term_rows(token, SenseLevel_Emotion_Lexicon)\n",
    "\n",
    "            # For each affect, we count the number of entries that are True for that term and affect\n",
    "            for i, affect in enumerate(Affects):\n",
    "                affect_counter = Counter(term_rows[affect].values)\n",
    "                true_count = affect_counter[True]\n",
    "\n",
    "                # We add the number of Trues to the value for the affect\n",
    "                present_affects[affect] += true_count\n",
    "\n",
    "            # For each Polarity (negative, positive), we count the number of entries that are True for that term and polarity\n",
    "            for i, pol in enumerate(Polarities):\n",
    "                pol_counter = Counter(term_rows[pol].values)\n",
    "                true_count = pol_counter[True]\n",
    "\n",
    "                # We add the number of Trues to the value for the polarity\n",
    "                present_polarities[pol] += true_count\n",
    "    \n",
    "    return present_affects, present_polarities\n",
    "\n",
    "\n",
    "# Output Example\n",
    "test_positive = \"Hello, I am feeling great today\"\n",
    "message_affects, message_polarities = get_affects_and_polarities(test_positive)\n",
    "print(\"Test string:\", test_positive, '\\n', '-' * 40)\n",
    "print(\"Affects:\", message_affects)\n",
    "print(\"Polarities:\", message_polarities)\n",
    "print(\"Positive Polarity:\", message_polarities['positive'])\n",
    "\n",
    "\n",
    "print()\n",
    "\n",
    "\n",
    "test_negative = \"Hello, I am feeling bad today\"\n",
    "message_affects, message_polarities = get_affects_and_polarities(test_negative)\n",
    "print(\"Test string:\", test_negative, '\\n', '-' * 40)\n",
    "print(\"Affects:\", message_affects)\n",
    "print(\"Polarities:\", message_polarities)\n",
    "print(\"Positive Polarity:\", message_polarities['positive'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![ChatBot](https://raw.githubusercontent.com/alahnala/AI4All2020-Michigan-NLP/master/slides/Chatbot-NewRule.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add some rules to the Chatbot Starter code so that the bot responds appropriately based on the user's emotions\n",
    "\n",
    "This is where you can get creative! Here are some suggestions to get started:\n",
    "\n",
    "1. Add a special response for when the user's message is more positive than negative -- this has been added already as an example, see the code under the NEW and NEW RULE comments\n",
    "2. Add a special response for when the user's message is more negative than positive\n",
    "3. Test out your rules with your own messages. Add new rules to account for situations that you observe.\n",
    "4. Try making some responses that take the affects into account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_input():\n",
    "    \n",
    "    user_message = input()\n",
    "    return user_message\n",
    "\n",
    "def get_bot_reply(user_message):\n",
    "    \n",
    "    Continue_Session = True\n",
    "    \n",
    "    # NEW\n",
    "    message_affects, message_polarities = get_affects_and_polarities(user_message)\n",
    "    \n",
    "    # Make print statements like the one below to understand what's going on (remove # to use this one) \n",
    "    #print(message_polarities)\n",
    "    \n",
    "    bot_reply = 'No rule to handle this message yet.'\n",
    "    \n",
    "    if user_message.lower().strip() == 'quit':\n",
    "        Continue_Session = False\n",
    "        bot_reply = 'Thank you for chatting!'\n",
    "        \n",
    "    # NEW RULE\n",
    "    elif message_polarities['positive'] > message_polarities['negative']:\n",
    "        bot_reply = 'It sounds like things are going well, yes?'\n",
    "\n",
    "    return bot_reply, Continue_Session"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test out the example rule\n",
    "\n",
    "Start the chatbot and respond with **\"*Hello, I am feeling great today*\"** to observe the bot's new response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Continue_Session = True\n",
    "\n",
    "Welcome_Message = 'Welcome to the chatbot! To quit, type \"quit\". How are you feeling today?'\n",
    "\n",
    "print(\"Computer:\", Welcome_Message)\n",
    "\n",
    "while Continue_Session:\n",
    "    print(\"Me:\", end=' ', flush=True)\n",
    "    user_message = get_input()\n",
    "    bot_reply, Continue_Session = get_bot_reply(user_message)\n",
    "    print(\"Computer:\", bot_reply)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Continue adding rules to your bot. Get creative!\n",
    "\n",
    "Get creative with your bot, including changing the Welcome message. Have a friend, family member, or AI4All peer or instructor test it out.\n",
    "\n",
    "Here are a couple of challenges to consider:\n",
    "1. Can you make your bot respond with empathy for all of the emotions? \n",
    "2. Can you improve the way we determine the emotion and sentiment, rather than just counting the sentiments?\n",
    "3. Can you incorporate anything you learned from the previous parts of the NLP project to improve your bot?\n",
    "4. Consider taking into account the full message history into account. How would you keep track of changes in user emotion? For example, maybe I start the conversation saying I feel happy, but later I am telling a sad story. Would the bot respond different when I switch to being sad if I were happy earlier than if I were sad earlier as well?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# References the lexicons used are introduced in these papers below. These are also great resources to read to learn from!\n",
    "\n",
    "NRC Emotion Intensity Lexicon: association of words with eight basic emotions (anger, anticipation, disgust, fear, joy, sadness, surprise, and trust). The lexicon with its fine-grained real-valued scores was created by manual annotation using Best--Worst Scaling. Available in over 100 different languages.\n",
    "\tVersion: 1.0\n",
    "\tNumber of terms: ~10,000 unigrams (words)\n",
    "\tAssociation scores: real-valued\n",
    "\tCreator: Saif M. Mohammad\n",
    "\n",
    "\tPapers:\n",
    "\n",
    "\tSaif M. Mohammad (2018). Word Affect Intensities. In Proceedings of the 11th edition of the Language Resources and Evaluation Conference, May 2018, Miyazaki, Japan.\n",
    "    \n",
    "    \n",
    "NRC Emotion Lexicon: association of words with eight emotions (anger, fear, anticipation, trust, surprise, sadness, joy, and disgust) and two sentiments (negative and positive) manually annotated on Amazon's Mechanical Turk. Available in 105 different languages.\n",
    "\tVersion: 0.92\n",
    "\tNumber of terms: 14,182 unigrams (words), ~25,000 word senses\n",
    "\tAssociation scores: binary (associated or not)\n",
    "\tCreators: Saif M. Mohammad and Peter D. Turney\n",
    "\n",
    "\tPapers:\n",
    "\n",
    "\tSaif Mohammad and Peter Turney (2013). Crowdsourcing a Word-Emotion Association Lexicon. Computational Intelligence, 29 (3), 436-465, 2013.\n",
    "\n",
    "\tSaif Mohammad and Peter Turney (2010). Emotions Evoked by Common Words and Phrases: Using Mechanical Turk to Create an Emotion Lexicon, In Proceedings of the NAACL-HLT 2010 Workshop on Computational Approaches to Analysis and Generation of Emotion in Text, June 2010, LA, California."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}