notebook/Using+Watson+Explorer+for+Sentiment+Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using Watson Explorer for Sentiment Analysis\n",
    "\n",
    "This notebook shows you how to use Watson Explorer from DSX Local to analyze unstructured content to perform sentiment analysis.\n",
    "\n",
    "The data sets for this notebook are real world data from the Airbnb guest reviews of their lodging experience. You'll learn the basic steps to analyze the unstructured data through Watson Explorer and narrow the focus on your unstructured data quickly. In the process you will use Python and WEX, and create sentiment heatmaps."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of contents\n",
    "This notebook contains the followiong main sections:\n",
    "\n",
    "- [Prepare the environment](#prepare_environment)\n",
    "- [Load data](#load_data)\n",
    "- [Create a Dataset](#create_dataset)\n",
    "- [Add documents to the Dataset](#add_documents)\n",
    "- [Locate Part-of-Speech and Sentiment enrichments](#locate_enrichment)\n",
    "- [Create a collection](#create_collection)\n",
    "- [Analyze positive targets](#analyze_positive_target)\n",
    "- [Summary](#summary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='prepare_environment'></a>\n",
    "## Prepare the environment\n",
    "To access Watson Explorer from the notebook, import Watson Explorer Python libraries and specify the endpoint and access information to your Watson Explorer deployment with the following code sample."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ibmwex\n",
    "\n",
    "import urllib3\n",
    "urllib3.disable_warnings()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify the endpoint and access information\n",
    "configuration = ibmwex.Configuration()\n",
    "configuration.host = 'https://WEX-RELEASE-NAME-ibm-wex-prod-ui.NAMESPACE:30443'\n",
    "configuration.username = 'admin'\n",
    "configuration.password = 'admin'\n",
    "configuration.verify_ssl = False\n",
    "\n",
    "# Create a client instance\n",
    "api_client = ibmwex.ApiClient()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='load_data'></a>\n",
    "## Load data\n",
    "The Airbnb reviews for Boston data set can be obtained from [Inside Airbnb](http://insideairbnb.com/about.html).\n",
    "\n",
    "To get your access key link and load this data set:\n",
    "1. Find the data set and obtain an access key link:\n",
    "    1. On the Data Science Experience home page, search for \"airbnb\".\n",
    "    1. Click the card with the title [Airbnb Data for Analytics: Boston Reviews](https://datascience.ibm.com/exchange/public/entry/view/107ab470f90be9a4815791d8ec8c2a9e).\n",
    "    1. Click the link button.\n",
    "    1. Hover above the link button next to the access key to display the link.\n",
    "    1. Double-click the link to select it, copy the link, and click **Close**.\n",
    "    1. Insert the access key link and run the cell to load the data:\n",
    "    1. In the cell below, replace the **LINK-TO-DATA** string in the `read_csv()` method with the link.\n",
    "    1. To verify functionality, and see how to load data, run the following cell to import the pandas and numpy libraries, rename and load five columns of the data into the DataFrame, and show the first five rows of guest review data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>date</th>\n",
       "      <th>reviewer</th>\n",
       "      <th>comments</th>\n",
       "      <th>host</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>19454962</td>\n",
       "      <td>2014-09-13</td>\n",
       "      <td>Jorji</td>\n",
       "      <td>What a fantastic place to stay during our week...</td>\n",
       "      <td>Carlos And Cheryl</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>30021361</td>\n",
       "      <td>2015-04-16</td>\n",
       "      <td>David</td>\n",
       "      <td>Great location and apartment. We would definit...</td>\n",
       "      <td>Carlos And Cheryl</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>31423904</td>\n",
       "      <td>2015-05-05</td>\n",
       "      <td>Theresa</td>\n",
       "      <td>The apartment was neat and clean and accuratel...</td>\n",
       "      <td>Carlos And Cheryl</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>31933451</td>\n",
       "      <td>2015-05-12</td>\n",
       "      <td>Neema</td>\n",
       "      <td>I absolutely loved the location of the apartme...</td>\n",
       "      <td>Carlos And Cheryl</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>34269995</td>\n",
       "      <td>2015-06-07</td>\n",
       "      <td>Aine</td>\n",
       "      <td>My family and I stayed in Boston in June 2015....</td>\n",
       "      <td>Carlos And Cheryl</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         id        date reviewer  \\\n",
       "0  19454962  2014-09-13    Jorji   \n",
       "1  30021361  2015-04-16    David   \n",
       "2  31423904  2015-05-05  Theresa   \n",
       "3  31933451  2015-05-12    Neema   \n",
       "4  34269995  2015-06-07     Aine   \n",
       "\n",
       "                                            comments               host  \n",
       "0  What a fantastic place to stay during our week...  Carlos And Cheryl  \n",
       "1  Great location and apartment. We would definit...  Carlos And Cheryl  \n",
       "2  The apartment was neat and clean and accuratel...  Carlos And Cheryl  \n",
       "3  I absolutely loved the location of the apartme...  Carlos And Cheryl  \n",
       "4  My family and I stayed in Boston in June 2015....  Carlos And Cheryl  "
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# Guest reviews\n",
    "reviews = pd.read_csv(\"LINK-TO-DATA\", usecols=['id','date','reviewer_name','comments','host_name'])\n",
    "reviews.columns=['id','date','reviewer','comments','host']\n",
    "reviews[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='create_dataset'></a>\n",
    "## Create a Dataset\n",
    "A Dataset is a container where documents are stored for analysis. You can use crawlers and importers to import your data into the Dataset. Once your data is loaded into the Dataset, you can associate it to a Collection and then begin analysis.\n",
    "\n",
    "The following python code creates a Dataset named 'Airbnb Data : Boston Reviews' with the four fields of date, reviewer, host, and comments:\n",
    "* `date` : Review date\n",
    "* `reviewer` : Reviewer name\n",
    "* `host` : Host name\n",
    "* `comments` : Review comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Airbnb Data : Boston Reviews\n"
     ]
    }
   ],
   "source": [
    "# Create a Dataset\n",
    "api_datasets = ibmwex.DatasetApi(api_client)\n",
    "dataset = ibmwex.Dataset()\n",
    "dataset.name = 'Airbnb Data : Boston Reviews'\n",
    "dataset.fields = [ibmwex.Field(name='date', type='Date'), ibmwex.Field(name='reviewer', type='String'), ibmwex.Field(name='comments', type='String'), ibmwex.Field(name='host', type='String')]\n",
    "dataset = api_datasets.create(dataset)\n",
    "\n",
    "print(dataset.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='add_documents'></a>\n",
    "## Add documents to the Dataset\n",
    "In this step, you will use REST API to push data directly into the Dataset. For illustrative purposes, the following python code adds the first 1000 documents of Airnbn review data to the Dataset created in the previous step."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Airbnb Data : Boston Reviews\n"
     ]
    }
   ],
   "source": [
    "# Add documents\n",
    "documents = []\n",
    "for review in reviews[0:1000].fillna({'reviewer':'','comments':'','host':''}).itertuples(index=False):\n",
    "    document = ibmwex.Document(id=str(review.id), fields={'date':review.date, 'reviewer':review.reviewer, 'comments':review.comments, 'host':review.host}, tag='airbnb_data/boston_reviews')\n",
    "    documents.append(document)\n",
    "    \n",
    "dataset = api_datasets.add_document(dataset.id, documents)\n",
    "\n",
    "print(dataset.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='locate_enrichment'></a>\n",
    "## Locate Part-of-Speech and Sentiment enrichments\n",
    "The next step in performing sentiment analysis will be to analyze the `comments` field and extract linguistic attributes and sentiment expressions. Use the WEX library api's as demonstrated in the python code below to extract words, phrases, and sentiment expressions, retrieve Part-of-Speech and Sentiment enrichment information."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Part of Speech\n",
      "Sentiment Analysis\n"
     ]
    }
   ],
   "source": [
    "# Retrieve PoS and Sentiment enrichments\n",
    "pos = None\n",
    "sentiment = None\n",
    "api_enrichments = ibmwex.EnrichmentApi(api_client)\n",
    "for enrichment in api_enrichments.list().items:\n",
    "    if enrichment.type == 'pos':\n",
    "        pos = enrichment\n",
    "    elif enrichment.type == 'sentiment':\n",
    "        sentiment = enrichment\n",
    "\n",
    "print(pos.name)\n",
    "print(sentiment.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='create_collection'></a>\n",
    "## Create a collection\n",
    "A collection is defined as a source dataset and set of enrichments to be applied to the dataset. The documents in the source dataset are enriched through natural langauge processing known as enrichments.\n",
    "\n",
    "In this step, you will apply Part-of-Speech and Sentiment enrichments to the `comments` field to extract reviewer sentiment expressions about hosts. The following python code creates a collection named 'Airbnb Data : Boston Reviews' with Part-of-Speech and Sentiment enrichments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Airbnb Data : Boston Reviews\n"
     ]
    }
   ],
   "source": [
    "api_collections = ibmwex.CollectionApi(api_client)\n",
    "collection = ibmwex.Collection()\n",
    "# Collection name\n",
    "collection.name = 'Airbnb Data : Boston Reviews'\n",
    "# Link the dataset\n",
    "collection.datasets = [dataset.id]\n",
    "# Link PoS and Sentiment enrichments\n",
    "collection.enrichments = [pos.id, sentiment.id]\n",
    "# Use the comment field as document body\n",
    "collection.enrich_field_groups = [ibmwex.EnrichFieldGroup(enrichments=[pos.id, sentiment.id], fields=['comments'])]\n",
    "collection.tags = {'defaultBodyFieldId':'comments'}\n",
    "# Define facets tree\n",
    "collection.category = pos.category\n",
    "collection.category.children.extend(sentiment.category.children)\n",
    "# Create a collection\n",
    "collection = api_collections.create(collection)\n",
    "\n",
    "print(collection.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since indexing is not instantaneous, the following code will wait until the timeout value of 10 minutes for the index creation to complete. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wait until indexing is finished...\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def wait_collection(api_collections, id, timeout_secs=600, period_secs=10):\n",
    "    mustend = time.time() + timeout_secs\n",
    "    while (time.time() < mustend):\n",
    "        completed = True\n",
    "        status = api_collections.status(id).docproc\n",
    "        completed = status.completed\n",
    "        if completed: return True\n",
    "\n",
    "        time.sleep(period_secs)\n",
    "    print(\"Time out\")\n",
    "    return False\n",
    "\n",
    "\n",
    "print('Wait until indexing is finished...')\n",
    "wait_collection(api_collections, collection.id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='analyze_positive_target'></a>\n",
    "## Analyze positive targets\n",
    "\n",
    "The following code uses the collection that has been created so far to generate and display a positive target facet pair heatmap."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[Text(69,0.5,'Host'), Text(0.5,69,'Positive Target')]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f5c03257780>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_dim = 'host'\n",
    "x_label = 'Host'\n",
    "y_dim = 'annotation._sentiment.target.positive'\n",
    "y_label = 'Positive Target'\n",
    "\n",
    "api_exploration = ibmwex.ExplorationApi(api_client)\n",
    "results = api_exploration.query(collection.id, '*:*', rows=0, facet='true', \n",
    "    facet_field=[x_dim,y_dim], facet_stats='pairs', facet_limit=15)\n",
    "\n",
    "fs = results.facet_stats\n",
    "\n",
    "x_labels = list(map(lambda i: i['id'], fs.dims[x_dim]))\n",
    "y_labels = list(map(lambda i: i['id'], fs.dims[y_dim]))\n",
    "correlation_matrix = list(\n",
    "    map(lambda  x : list(map(lambda y : y['correlation'], x)),\n",
    "        list(map(lambda x : x[y_dim], fs.stats['pairs'][x_dim]))\n",
    "    )\n",
    ")\n",
    "\n",
    "%pylab inline\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "sns.set(style=\"whitegrid\")\n",
    "sns.set_color_codes(\"pastel\")\n",
    "\n",
    "f, ax = plt.subplots(1, 1, figsize=(10,10))\n",
    "sns.heatmap(correlation_matrix, xticklabels=y_labels, yticklabels=x_labels, cbar=False, cmap='Blues')\n",
    "ax.set(xlabel=y_label, ylabel=x_label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='summary'></a>\n",
    "## Summary\n",
    "\n",
    "In this notebook you have learned how to use Watson Explorer from DSX Local to analyze unstructured content to perform sentiment analysis using data sets for that are directly obtained real world data from the Airbnb's guest reviews from their lodging experience. You learned the basic steps to analyze the unstructured data through the Watson Explorer and narrow the focus on your unstructured data using python, python and WEX libraries, and create sentiment heatmaps."
   ]
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}