project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ADA PROJECT - Amazon Kindle User Experience\n",
    "### MILESTONE 3\n",
    "### E. Bonvin, D. Dudzicz, X. Pantet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project Presentation and Research Questions Summary\n",
    "\n",
    "In the scope of our project, we decided to analyze the impact of the Amazon's Kindle on its customers' reading habits. We are interested in seeing whether the e-reader from the e-commerce giant has an effect on users' behaviour and if it does, how these are being modified. Our main analysis axis were the variations and shifts in tendencies that can be observed from the launch of the Kindle in November 2007 until 2014.\n",
    "\n",
    "We articulate our analysis around the following research questions:\n",
    "\n",
    "- Is the Kindle getting more readers than classical books with respect to the size of the available titles catalogs?\n",
    "- Has the Kindle changed frequent readers' reading habits or reading pace?\n",
    "- Is the Kindle successfuly retaining the new users who try it?\n",
    "- How important is the Kindle in the proportion of books read for frequent users?\n",
    "- How is users' ebooks-books proportion varying in time?\n",
    "- Is the technical aspect of the medium an important satisfaction factors in customers' reviews?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results Computation Disclaimer\n",
    "\n",
    "Due to Jupyter Notebooks tendency to halt for no reason, its repeated crashes with heavy computations and Pyspark's habit not to implement a lot of common MySQL operators, a lot of presented results had to be computed using Python 3 and Scala Spark without Jupyter Notebook. Those results are imported and appear to be magic values but they are not. We also spare the reader with boring extensive SQL querying given its simplicity and tediousness."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 617,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Imports of mathematical and statistical libraries\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import statistics\n",
    "\n",
    "#Imports of pyspark functions\n",
    "from pyspark.sql import *\n",
    "from pyspark.sql.functions import *\n",
    "from pyspark.sql.types import StructType, StructField, IntegerType, StringType, FloatType\n",
    "from pyspark.sql.functions import col\n",
    "import os.path\n",
    "import findspark\n",
    "\n",
    "#Imports of graphical representations and plotting libraries\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as snb\n",
    "from ipysankeywidget import SankeyWidget\n",
    "from ipywidgets import Layout\n",
    "from IPython.display import Image\n",
    "\n",
    "#Imports for LDA\n",
    "from collections import Counter\n",
    "from pyspark.ml.clustering import LDA, LDAModel, DistributedLDAModel\n",
    "from pyspark.ml.linalg import Vectors\n",
    "\n",
    "#Imports of natural language processing libraries\n",
    "from textblob import TextBlob\n",
    "from nltk.stem.snowball import SnowballStemmer\n",
    "\n",
    "#PySpark SQL context creation\n",
    "findspark.init()\n",
    "sc = pyspark.SparkContext()\n",
    "sc.setCheckpointDir('checkpoint/')\n",
    "spark = SparkSession.builder.getOrCreate()\n",
    "sqlContext = SQLContext(spark)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis Structure\n",
    "\n",
    "Our analysis is divided into two main parts. The first one tackles the purely quantitative and numerical aspects of the reviews. We analyze the number and proportion of users for each platform, their monthly consumption, etc.\n",
    "\n",
    "The second one presents a sentiment analysis on the review texts of the Kindle in order to enhance the precision of the tendency observed in part one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datasets Used\n",
    "\n",
    "We use four datasets consisting of Amazon reviews gathered by Julian McAuley (UCSD) available on http://jmcauley.ucsd.edu/data/amazon/. These datasets contain various amazon customers reviews collected from May 1996 to July 2014.\n",
    "\n",
    "The data is very-well formated thanks to the work of the author and is categorized given the kind of item being reviewed. We used the following datasets:\n",
    "\n",
    "- ratings_Books.csv (~900MB)\n",
    "- ratings_Kindle_Store.csv (~130MB)\n",
    "- reviews_Books.json (~20GB)\n",
    "- reviews_Kindle_Store.json (~2.2GB)\n",
    "\n",
    "The two first datasets are simplified versions of their respective latter files. They are much lighter, only presenting numerical values of the reviews. They consist of 4-tuples:\n",
    "\n",
    "- __userID:__ a unique ID of each customer that is coherent among all dataset present on the website\n",
    "- __ASIN:__ the unique amazon product id number\n",
    "- __rating:__ the rating of the review in the range [1,5] stars\n",
    "- __unixTimestamp:__ the timestamp in the UNIX epoch format\n",
    "\n",
    "The last two datasets are much more complete:\n",
    "\n",
    "- __userID__\n",
    "- __ASIN__\n",
    "- __userName:__ the customer real name\n",
    "- __helpful:__ the helpfulness of the review as a ratio given by other amazon customers\n",
    "- __reviewText:__ the review text itself\n",
    "- __rating__\n",
    "- __summary:__ the summary of the review\n",
    "- __unixTimestamp__\n",
    "- __reviewTime:__ timestamp in a human readable format\n",
    "\n",
    "Even though, these datasets hold a lot of informations, we focused only on the `reviewText` field. Indeed, all the key aspects that we needed for the first part of the analysis are present in the two first reduced datasets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Cleaning\n",
    "\n",
    "Since the datasets are very well formated thanks to the work of Julian McAuley (UCSD), we do not have any data cleaning to do properly speaking. On the other hand, there are some inconsistencies in the ratings and reviews that we have to deal with (too many reviews per user per period of time, incoherent `reviewTime` given the release date of the Kindle) that need to be filtered. Those are explained in the latter parts when needed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Loading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define the global environment variables that allow us to read data and store intermediate results during our work. We also define schema for .csv file imports but not for .json which do not require it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Global variable definitions\n",
    "DATA_FOLDER = 'data/'\n",
    "RESULT_FOLDER = 'results/'\n",
    "RDD_FILENAME = \"stemstem.parquet\"\n",
    "\n",
    "#Name of the datasets files downloaded from http://jmcauley.ucsd.edu/data/amazon/\n",
    "RATINGS_KINDLE = 'ratings_Kindle_Store.csv'\n",
    "RATINGS_BOOKS = 'ratings_Books.csv'\n",
    "\n",
    "#Schema for books and kindle ratings\n",
    "RATINGS_SCHEMA = StructType([\n",
    "    StructField(\"User\", StringType(), True),\n",
    "    StructField(\"Asin\", StringType(), True),\n",
    "    StructField(\"Ratings\", FloatType(), True),\n",
    "    StructField(\"Timestamp\", IntegerType(), True)])\n",
    "\n",
    "#Schema for reading saved kindle catalogue size\n",
    "KINDLE_CATALOGUE_SCHEMA = StructType([\n",
    "    StructField(\"Year\", IntegerType(), True),\n",
    "    StructField(\"Kindle_catalogue_size\", IntegerType(), True)])\n",
    "\n",
    "#Schema for reading saved books catalogue size\n",
    "BOOKS_CATALOGUE_SCHEMA = StructType([\n",
    "    StructField(\"Year\", IntegerType(), True),\n",
    "    StructField(\"Books_catalogue_size\", IntegerType(), True)])\n",
    "\n",
    "RATINGS_USER = 0\n",
    "RATINGS_ASIN = 1\n",
    "RATINGS_RATINGS = 2\n",
    "RATINGS_TIMESTAMP = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ratings datasets\n",
    "\n",
    "# Kindle\n",
    "df_ratings_kindle = spark.read.csv(DATA_FOLDER + RATINGS_KINDLE, header = False, schema = RATINGS_SCHEMA)\n",
    "print(\"---Kindle rating data sample---\")\n",
    "print(df_ratings_kindle.head(5))\n",
    "\n",
    "# Books\n",
    "df_ratings_books = spark.read.csv(DATA_FOLDER + RATINGS_BOOKS, header = False, schema = RATINGS_SCHEMA)\n",
    "print(\"---Books rating data sample---\")\n",
    "print(df_ratings_books.head(5))\n",
    "\n",
    "#We register the datasets to be used in the SQL queries in the latter parts\n",
    "df_ratings_kindle.registerTempTable(\"ratings_kindle\")\n",
    "df_ratings_books.registerTempTable(\"ratings_books\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Reviews datasets\n",
    "df_kindle_reviews = spark.read.json(\"data/reviews_Kindle_Store.json\")\n",
    "df_books_reviews = spark.read.json(\"data/reviews_Books.json\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 1 - Quantitative results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Kindle popularity growth\n",
    "\n",
    "In this subpart, we desire to observe if the Kindle appeals more to new users than books. We desire to observe the tendency with respect to the size of the ebooks and books catalogs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We previously computed the size of the catalogue of the kindle and books on amazon per year and we stored it in parquet files\n",
    "#we do not include the detail of the computations as it is very simple and tidious SQL queries which will be still very present\n",
    "#in the rest of the notebook.\n",
    "df_kindle_catalogue_years = spark.read.csv(RESULT_FOLDER+'kindle_catalogue_size_year.csv', header = False, schema = KINDLE_CATALOGUE_SCHEMA)\n",
    "df_kindle_catalogue_years.registerTempTable(\"df_kindle_catalogue_years\")\n",
    "df_books_catalogue_years = spark.read.csv(RESULT_FOLDER+'books_catalogue_years.csv', header = False, schema = BOOKS_CATALOGUE_SCHEMA)\n",
    "df_books_catalogue_years.registerTempTable(\"df_books_catalogue_years\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We compute the numbers of the new kindle users starting from 2008 since the kindle launched in 2007. Odly we have\n",
    "#observed that there were a lot of kindle reviews even before 2006. We need to filter this erroneous data first.\n",
    "kindle_new_users_by_years = spark.sql(\"\"\"\n",
    "                                SELECT year, COUNT(User) AS new_users\n",
    "                                FROM \n",
    "                                (SELECT User, YEAR(FROM_UNIXTIME(MIN(Timestamp))) AS year\n",
    "                                FROM ratings_kindle\n",
    "                                WHERE YEAR(FROM_UNIXTIME(Timestamp)) > 2007\n",
    "                                GROUP BY User)\n",
    "                                GROUP BY Year\n",
    "                                ORDER BY year\n",
    "                            \"\"\")\n",
    "kindle_new_users_by_years.registerTempTable(\"kindle_users_by_years\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We observed that the books variation was very important before the kindle appearance and we settled on a prior five year\n",
    "#before the kindle launched year basis for our books baseline.\n",
    "books_new_users_by_years = spark.sql(\"\"\"\n",
    "                                SELECT year, COUNT(User) AS new_users\n",
    "                                FROM \n",
    "                                (SELECT User, YEAR(FROM_UNIXTIME(MIN(Timestamp))) AS year\n",
    "                                FROM ratings_books\n",
    "                                WHERE YEAR(FROM_UNIXTIME(Timestamp)) > 2003 \n",
    "                                GROUP BY User)\n",
    "                                GROUP BY Year\n",
    "                                ORDER BY year\n",
    "                            \"\"\")\n",
    "books_new_users_by_years.registerTempTable(\"books_users_by_years\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Covnersion to pandas\n",
    "df_books_catalogue_years = df_books_catalogue_years.orderBy('Year').toPandas()\n",
    "df_kindle_catalogue_years = df_kindle_catalogue_years.orderBy('Year').toPandas()\n",
    "df_kindle_new_users_by_years = kindle_new_users_by_years.toPandas()\n",
    "df_books_new_users_by_years = books_new_users_by_years.toPandas()\n",
    "\n",
    "#Normalization and removal of 2014 outliers since the gathering wasn't complete for this last year.\n",
    "books_users_normalized = df_books_new_users_by_years['new_users']/df_books_catalogue_years['Books_catalogue_size']\n",
    "books_users_normalized = books_users_normalized[:-2]\n",
    "kindle_users_normalized = df_kindle_new_users_by_years['new_users']/df_kindle_catalogue_years['Kindle_catalogue_size']\n",
    "kindle_users_normalized = kindle_users_normalized[:-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "years1 = (df_kindle_new_users_by_years['year'])[:-1]\n",
    "years2 = (df_books_new_users_by_years['year'])[:-1]\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fig.set_size_inches(12, 6)\n",
    "plt.title(\"New users normalized by the catalogue size\")\n",
    "ax.plot(years1,kindle_users_normalized, label='normalized kindle growth')\n",
    "ax.plot(years2,books_users_normalized, label='normalized books growth')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It appears that __new users are more interested by the Kindle than by the books__ with respect to the size of the catalog. However both mediums have an important and __similar increase in growth starting in 2011__, in a similar manner as the Amazon.com brand popularity growth ref. [https://www.statista.com/chart/4298/amazons-long-term-growth/.] The fact that book curve is lower has to be nuanced, since the Amazon books offer was already present in 1996, almost 10 years before the first datapoint, we are plotting here. This has to be taken into account. Nonetheless, we can observe that the __Kindle has an important popularity among newcomers__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Change in frequent users' reading habits\n",
    "\n",
    "We observed in 1.1 that the the Kindle was able to appeal to newcomers, but has it been successfull in noticeably changing frequent users reading behaviour? We want to observe the effect of the Kindle on frequent users' reading habits and monthly pace of reading."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 443,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We need to get first users who consume both mediums in order to have a meaningful point of comparison. It would be\n",
    "#of little interest to compare separate popultions.\n",
    "common_users = spark.sql(\"\"\"SELECT DISTINCT ratings_books.User\n",
    "                            FROM ratings_books\n",
    "                            WHERE ratings_books.User\n",
    "                            IN (SELECT ratings_kindle.User\n",
    "                            FROM ratings_kindle\n",
    "                            WHERE YEAR(FROM_UNIXTIME(ratings_kindle.Timestamp)) > 2007)\"\"\")\n",
    "\n",
    "common_users.write.parquet(RESULT_FOLDER+\"common_users_list\")\n",
    "common_users = spark.read.parquet(RESULT_FOLDER+\"common_users_list\")\n",
    "common_users.registerTempTable(\"common_users\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We desire to obtain users who already owned books before the Kindle appearance.\n",
    "In this step we also filter out readers who consume __more than 30 books a month__. We decided to discard these outliers since we have discovered that amazon.com was victim of faked and spoofed ratings that aimed to artificially increase the grade of certain products ref. [https://www.independent.co.uk/news/business/news/amazon-bans-biased-reviews-incentivised-a7344761.html]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 447,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Users who owns a kindle an who were reading books before its appearance\n",
    "old_books_users = spark.sql(\"\"\"SELECT User, \n",
    "                                      YEAR(FROM_UNIXTIME(ratings_books.Timestamp)) AS year,\n",
    "                                      MONTH(FROM_UNIXTIME(ratings_books.Timestamp)) AS month,\n",
    "                                      COUNT(ASIN) as nb_books\n",
    "                                      FROM ratings_books\n",
    "                                      WHERE YEAR(FROM_UNIXTIME(ratings_books.Timestamp)) <= 2007 AND\n",
    "                                      YEAR(FROM_UNIXTIME(ratings_books.Timestamp)) >= 2004 AND\n",
    "                                      ratings_books.User IN\n",
    "                                          (SELECT * FROM common_users)\n",
    "                                      GROUP BY User, year, month\n",
    "                                      HAVING nb_books < 30\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing results to parquet and reading them to accelerate latter queries.\n",
    "old_books_users.write.parquet(RESULT_FOLDER+\"old_books_monthly_read\")\n",
    "old_books_monthly_read = spark.read.parquet(RESULT_FOLDER+\"old_books_monthly_read\")\n",
    "old_books_monthly_read.registerTempTable(\"old_books_monthly_read\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We desire to retain only frequent readers to have a better point of view of their habits. We define a threshold of __at least 6 books a year__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "old_books_users_avg_montly = spark.sql(\"\"\"SELECT year, month, AVG(nb_books) AS monthly_books\n",
    "                                          FROM old_books_monthly_read\n",
    "                                          JOIN (SELECT User \n",
    "                                                FROM old_books_monthly_read\n",
    "                                                GROUP BY User, Year\n",
    "                                                HAVING SUM(nb_books) > 5) t\n",
    "                                          ON  old_books_monthly_read.User = t.User     \n",
    "                                          GROUP BY year, month\n",
    "                                          ORDER BY year, month\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing results to parquet and reading them to accelerate latter queries.\n",
    "old_books_users_avg_montly.write.parquet(RESULT_FOLDER+ 'old_books_users_avg_montly')\n",
    "old_books_users_avg_montly = spark.read.parquet(RESULT_FOLDER+ 'old_books_users_avg_montly')\n",
    "old_books_users_avg_montly.registerTempTable(\"old_books_users_avg_montly\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#common users kindle ebooks purchases\n",
    "df_common_kindle = spark.sql(\"\"\"SELECT *\n",
    "                              FROM ratings_kindle\n",
    "                              WHERE YEAR(FROM_UNIXTIME(ratings_kindle.Timestamp)) > 2007 AND\n",
    "                              ratings_kindle.User IN\n",
    "                              (SELECT * FROM common_users)\"\"\")\n",
    "df_common_kindle.registerTempTable(\"common_kindle\")\n",
    "df_common_kindle.write.parquet(RESULT_FOLDER+\"kindle_reviews\")\n",
    "df_users_reduced = df_kindle_proportion_time.select('User')\n",
    "df_users_reduced.registerTempTable(\"df_users_reduced\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "#common users books purchases\n",
    "df_common_books = spark.sql(\"\"\"SELECT *\n",
    "                              FROM ratings_books\n",
    "                              WHERE YEAR(FROM_UNIXTIME(ratings_books.Timestamp)) > 2007 \n",
    "                              AND ratings_books.User IN\n",
    "                              (SELECT * FROM common_users)\"\"\")\n",
    "df_common_books.registerTempTable(\"common_books\")\n",
    "df_common_books.write.parquet(RESULT_FOLDER+\"books_review\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "common_books_user_time = spark.sql(\"\"\"SELECT User, YEAR(FROM_UNIXTIME(Timestamp)) AS Year, MONTH(FROM_UNIXTIME(Timestamp)) AS Month, COUNT(Asin) AS nb_books, AVG(Ratings) AS avg_book_rating\n",
    "                                  FROM common_books\n",
    "                                  GROUP BY User, YEAR(FROM_UNIXTIME(Timestamp)), MONTH(FROM_UNIXTIME(Timestamp))\"\"\")\n",
    "common_books_user.registerTempTable(\"common_books_user_time\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "common_kindle_user_time = spark.sql(\"\"\"SELECT User, YEAR(FROM_UNIXTIME(Timestamp)) AS Year, MONTH(FROM_UNIXTIME(Timestamp)) AS Month, COUNT(Asin) AS nb_ebooks, AVG(Ratings) AS avg_kindle_rating\n",
    "                                  FROM common_kindle\n",
    "                                  GROUP BY User, YEAR(FROM_UNIXTIME(Timestamp)), MONTH(FROM_UNIXTIME(Timestamp))\"\"\")\n",
    "common_kindle_user.registerTempTable(\"common_kindle_user_time\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "#Merge of the tables\n",
    "time_usage = spark.sql(\"\"\"SELECT \n",
    "                            common_kindle_user_time.User AS User,\n",
    "                            common_kindle_user_time.Year AS Year,\n",
    "                            common_kindle_user_time.Month as Month,\n",
    "                            common_kindle_user_time.nb_ebooks AS nb_ebooks,\n",
    "                            common_books_user_time.nb_books AS nb_books,\n",
    "                            common_kindle_user_time.avg_kindle_rating AS avg_kindle_rating,\n",
    "                            common_books_user_time.avg_book_rating AS avg_book_rating\n",
    "                            FROM common_kindle_user_time\n",
    "                            LEFT JOIN common_books_user_time\n",
    "                            ON (common_kindle_user_time.User = common_books_user_time.User \n",
    "                            AND common_kindle_user_time.Year = common_books_user_time.Year \n",
    "                            AND common_kindle_user_time.Month = common_books_user_time.Month )\n",
    "                            UNION\n",
    "                            SELECT common_books_user_time.User AS User,\n",
    "                            common_books_user_time.Year AS Year,\n",
    "                            common_books_user_time.Month AS Month,\n",
    "                            common_kindle_user_time.nb_ebooks AS nb_ebooks,\n",
    "                            common_books_user_time.nb_books AS nb_books,\n",
    "                            common_kindle_user_time.avg_kindle_rating AS avg_kindle_rating,\n",
    "                            common_books_user_time.avg_book_rating AS avg_book_rating\n",
    "                            FROM common_books_user_time\n",
    "                            LEFT JOIN common_kindle_user_time \n",
    "                            ON (common_kindle_user_time.User = common_books_user_time.User \n",
    "                            AND common_kindle_user_time.Year = common_books_user_time.Year \n",
    "                            AND common_kindle_user_time.Month = common_books_user_time.Month )\"\"\")\n",
    "\n",
    "time_usage.registerTempTable('time_usage')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Replacement of null by 0\n",
    "kindle_proportion_time =  spark.sql(\"\"\"SELECT User, \n",
    "                                              Year,\n",
    "                                              Month,\n",
    "                                              COALESCE(nb_ebooks, 0) AS nb_ebooks,\n",
    "                                              COALESCE(nb_books, 0) AS nb_books,\n",
    "                                              COALESCE(avg_kindle_rating, 0) AS avg_kindle_rating,\n",
    "                                              COALESCE(avg_book_rating, 0) AS avg_book_rating\n",
    "                                        FROM time_usage\"\"\")\n",
    "kindle_proportion_time.registerTempTable('kindle_proportion_time')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 453,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Writing of results into parquet file\n",
    "kindle_proportion_time.write.parquet(\"results/month_user_proportion.parquet\")\n",
    "df_kindle_proportion_time = spark.read.parquet(\"results/month_user_proportion.parquet\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 454,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+----+-----+---------+--------+-----------------+------------------+\n",
      "|          User|Year|Month|nb_ebooks|nb_books|avg_kindle_rating|   avg_book_rating|\n",
      "+--------------+----+-----+---------+--------+-----------------+------------------+\n",
      "|A104VB083XXPEY|2014|    4|        1|       1|              5.0|               5.0|\n",
      "|A16TE3MO6LY321|2012|    7|        1|       2|              1.0|               3.0|\n",
      "|A17MSEUE0J15D3|2011|    8|        1|      11|              2.0| 4.181818181818182|\n",
      "|A18MTONR63P37N|2014|    2|       13|      14|3.769230769230769|3.7857142857142856|\n",
      "|A197K9TWDPSSOU|2013|    6|        1|       5|              5.0|               4.8|\n",
      "|A1CHCZ0T4892PH|2012|    9|        2|       2|              4.5|               4.5|\n",
      "|A1CRJHHAKAWW4L|2014|    3|        1|       1|              5.0|               5.0|\n",
      "|A1DEK765QOHB2D|2013|    1|        1|       1|              5.0|               5.0|\n",
      "|A1EUEFNV11209V|2013|    5|        1|       4|              4.0|              4.25|\n",
      "|A1FW6EV5WN0IS1|2012|    3|        1|       1|              5.0|               5.0|\n",
      "+--------------+----+-----+---------+--------+-----------------+------------------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#A look of the database obtained\n",
    "df_kindle_proportion_time.show(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 449,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_kindle_proportion_time.registerTempTable(\"df_kindle_proportion_time\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We need to compute the reader average total number of books (ebooks and books) read by month for each year but also the reader average total number of only ebooks read by month for each year."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Books and kindle ebooks read monthly for each year\n",
    "books_read = spark.sql(\"\"\"SELECT * FROM ((SELECT Year, \n",
    "                                AVG(nb_books+nb_ebooks) AS monthly_books\n",
    "                                FROM df_kindle_proportion_time\n",
    "                                GROUP BY year)\n",
    "                                UNION\n",
    "                                (SELECT Year, AVG(monthly_books) AS monthly_books\n",
    "                                FROM old_books_users_avg_montly\n",
    "                                GROUP BY Year))\n",
    "                                ORDER BY Year\n",
    "                                \"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Only books read monthly for each year\n",
    "physical_books_read = spark.sql(\"\"\"SELECT * FROM ((SELECT Year, \n",
    "                                AVGnb_books AS monthly_books\n",
    "                                FROM df_kindle_proportion_time\n",
    "                                GROUP BY year)\n",
    "                                UNION\n",
    "                                (SELECT Year, AVG(monthly_books) AS monthly_books\n",
    "                                FROM old_books_users_avg_montly\n",
    "                                GROUP BY Year))\n",
    "                                ORDER BY Year\n",
    "                                \"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plotting of the two curves\n",
    "years = physical_books_read.toPandas()['Year'].values\n",
    "\n",
    "books = physical_books_read.toPandas()['monthly_books'].values\n",
    "total_books = books_read.toPandas()['monthly_books'].values\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fig.set_size_inches(12, 6)\n",
    "plt.title(\"Monthly number of books read as a function of the year\")\n",
    "ax.plot(years,books, label='only books')\n",
    "ax.plot(years,total_books, label='books and ebooks')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe that among frequent users, __the appearance of the Kindle hasn't increased the number of read books per month on average but replace a fraction of these__, approximately 1 out of 4 books is an ebook by 2014. We can see that the proportion of ebooks increased in an important manner but has a tendency to settle for the last period. (This has to be nuanced by the smaller dataset gathered for the last 2014 year). These numbers are not normalized by the respective titles catalog size of each platform. though."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 E-books to All-books ratio normalized by respective catalogue sizes\n",
    "\n",
    "Let us include the titles catalog size factor in the analysis of the previous tendency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We load a previously computed database constituted of previous results relative to user consumption of e-books and books per month for frequent readers and including the catalog size that has to be joined to them with the help of SQL queries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 451,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------------+----+-----+---------+--------+-----------------+-----------------+---------------------+--------------------+\n",
      "|                User|Year|Month|nb_ebooks|nb_books|avg_kindle_rating|  avg_book_rating|kindle_catalogue_size|books_catalogue_size|\n",
      "+--------------------+----+-----+---------+--------+-----------------+-----------------+---------------------+--------------------+\n",
      "|A0625983252ECA1NT...|2013|   11|        0|       1|              0.0|              5.0|               324302|             1903718|\n",
      "|A072353333NAMFEC9...|2013|    7|        0|       2|              0.0|              4.0|               324302|             1903718|\n",
      "|A07563631RVFIZLOCOYX|2013|    1|        1|       1|              5.0|              5.0|               324302|             1903718|\n",
      "|A07759332OIY0BZ48...|2013|    8|        0|       1|              0.0|              5.0|               324302|             1903718|\n",
      "|      A100BTJ98E8J68|2014|    3|        1|       2|              5.0|              5.0|               430506|             2168830|\n",
      "|      A100BX5ZTCBI39|2014|    4|        1|       2|              5.0|              5.0|               430506|             2168830|\n",
      "|      A1047EDJ84IMAS|2014|    2|        1|       1|              1.0|              1.0|               430506|             2168830|\n",
      "|      A104GP66XU8REZ|2013|    6|        0|       1|              0.0|              5.0|               324302|             1903718|\n",
      "|      A106NYN1QMTV8U|2013|   12|        1|       2|              5.0|              5.0|               324302|             1903718|\n",
      "|      A10744IS5OVECX|2012|    9|        2|       3|              4.5|4.666666666666667|               153658|             1410246|\n",
      "+--------------------+----+-----+---------+--------+-----------------+-----------------+---------------------+--------------------+\n",
      "only showing top 10 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "kindle_proportion_time_factors = spark.read.parquet(\"results/df_kindle_proportion_time_factors.parquet\")\n",
    "kindle_proportion_time_factors.registerTempTable(\"kindle_proportion_time_factors\")\n",
    "kindle_proportion_time_factors.show(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 455,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+--------------------+-------------------+\n",
      "|Year|               ratio|                std|\n",
      "+----+--------------------+-------------------+\n",
      "|2008|0.026952544410628658| 0.1252574263034488|\n",
      "|2009| 0.05535833968654787|0.17710264142519203|\n",
      "|2010| 0.15182029796122012| 0.2771360628238975|\n",
      "|2011| 0.38443060676477814| 0.3457885001934083|\n",
      "|2012|  0.5070162664030109| 0.2991928594205472|\n",
      "|2013| 0.47604236503290687|0.24983270422877646|\n",
      "|2014|  0.5048594924349231|0.24439432980144282|\n",
      "+----+--------------------+-------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "normalized_proportion = spark.sql(\"\"\"SELECT Year, AVG(ratio) AS ratio, STDDEV(ratio) AS std\n",
    "                FROM (SELECT User, Year, AVG((nb_ebooks/kindle_catalogue_size)/(nb_ebooks/kindle_catalogue_size+nb_books/books_catalogue_size)) AS ratio\n",
    "                 FROM kindle_proportion_time_factors\n",
    "                 GROUP BY User, Year)\n",
    "             GROUP BY Year\n",
    "             ORDER BY Year\"\"\")\n",
    "df_normalized_proportion = normalized_proportion.toPandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us plot this results as a error bar plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 457,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "yerr = df_normalized_proportion['std'].values\n",
    "y = df_normalized_proportion['ratio'].values\n",
    "years =  df_normalized_proportion['Year'].values\n",
    "fig, ax = plt.subplots()\n",
    "fig.set_size_inches(12, 6)\n",
    "plt.title(\"Normalized ebooks, books ratio as a function of time\")\n",
    "ax.errorbar(x = years, y= y,yerr = yerr, fmt='-o')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe a __similar growth then stabilization tendency__ for the normalized ratios. However we observe that the standard deviation is very important for each year. From this aspect, we decide to do a more in-depth analysis which focuses on the variation of each Kindle ratio population proportion with respect to the total number of frequent readers. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 Proportion of readers given their e-books ratio\n",
    "\n",
    "We compute and plot the proportion of users for each 10%-width bin e-books to total books ratio as a relative stacked vertical barplot for each year from 2008 to 2014. The numbers used where tediously computed using very boring and extravagant SQL queries which we preserve the reader from."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 508,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Precomputed values with the help of SQL queries \n",
    "p_90_100 = np.array([0,0,0,0,0.0000294628,0.00001680711,0.00003006657])\n",
    "p_80_90  = np.array([0,0,0.00030873726,0.00011118783,0.00017677682809337354,0.00019664329888798213,0.0001403107040229885])\n",
    "p_70_80  = np.array([0,0,0,0.0002601795238714713,0.0008398158428652431,0.0009062691166141786,0.000781731065270936])\n",
    "p_60_70  = np.array([0,0.0009398496240601503,0.0006174745291756716,0.0011826341994157785,0.0019113050216933122,0.0030009477352035538,0.0023552153889573072])\n",
    "p_50_60  = np.array([0.0018181818181818182,0.003289473684210526,0.01173201605433776,0.04612273377721537,0.07465673251402058,0.062301726912901124,0.08396593416461413])\n",
    "p_40_50  = np.array([0.0024242424242424242,0.005639097744360902,0.029021302871256562,0.10714665846706954,0.18168981372884607,0.16197423032316619,0.21184911868842365])\n",
    "p_30_40  = np.array([0.004242424242424243,0.007518796992481203,0.02994751466502007,0.09129936019489811,0.14763383334231067,0.15830640531347293,0.17770350664511497])\n",
    "p_20_30  = np.array([0.006666666666666667,0.019736842105263157,0.04970669959864156,0.1362394597726977,0.17511608282090088,0.19948180215888694,0.19493165666050905])\n",
    "p_10_20  = np.array([0.01696969696969697,0.044642857142857144,0.09694350108058043,0.20199392126021498,0.22657652257164354,0.27173538993724944,0.22295370869252873])\n",
    "p_0_10   = np.array([0.9757575757575757,0.9356203007518797,0.7968508799012042,0.43118842910699284,0.20841912486555708,0.16000779733428636,0.12228077855603449])\n",
    "\n",
    "years = (2008,2009,2010,2011,2012,2013,2014)\n",
    "ind = (np.arange(7))    # the x locations for the groups\n",
    "width = 0.35       # the width of the bars: can also be len(x) sequence\n",
    "plt.figure(figsize=(10,5))\n",
    "\n",
    "p1 = plt.bar(ind, p_90_100, width)\n",
    "\n",
    "p2 = plt.bar(ind, p_80_90, width,\n",
    "            bottom=p_90_100)\n",
    "\n",
    "p3 = plt.bar(ind, p_70_80, width,\n",
    "            bottom=p_90_100+p_80_90)\n",
    "\n",
    "p4 = plt.bar(ind, p_60_70, width,\n",
    "            bottom=p_90_100+p_80_90+p_70_80)\n",
    "\n",
    "p5 = plt.bar(ind, p_50_60, width,\n",
    "              bottom=p_90_100+p_80_90+p_70_80+p_60_70)\n",
    "\n",
    "p6 = plt.bar(ind, p_40_50, width,\n",
    "            bottom=p_90_100+p_80_90+p_70_80+p_60_70+p_50_60)\n",
    "\n",
    "p7 = plt.bar(ind, p_30_40, width,\n",
    "            bottom=p_90_100+p_80_90+p_70_80+p_60_70+p_50_60+p_40_50)\n",
    "\n",
    "p8 = plt.bar(ind, p_20_30, width,\n",
    "            bottom=p_90_100+p_80_90+p_70_80+p_60_70+p_50_60+p_40_50+p_30_40)\n",
    "\n",
    "p9 = plt.bar(ind, p_10_20, width,\n",
    "            bottom=p_90_100+p_80_90+p_70_80+p_60_70+p_50_60+p_40_50+p_30_40+p_20_30)\n",
    "\n",
    "p10 = plt.bar(ind, p_0_10, width,\n",
    "            bottom=p_90_100+p_80_90+p_70_80+p_60_70+p_50_60+p_40_50+p_30_40+p_20_30+p_10_20)\n",
    "plt.ylabel('Proportion of users')\n",
    "plt.title('Histogram proportion of users given their ebooks, books ratio')\n",
    "plt.xticks(ind, years)\n",
    "plt.yticks(np.arange(0, 1.1, 0.1))\n",
    "plt.legend((p1[0],p2[0],p3[0],p4[0],p5[0],p6[0],p7[0],p8[0],p9[0],p10[0]), ('90-100%','80-90%','70-80%','60-70%','50-60%','40-50%','30-40%','20-30%','10-20%','0-10%'))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe that the intermetdiate e-books ratios such as 10-20%, 30-40%, 40-50% __have a tendency to increase over the years and represent an important proportion of the total readers__. However the higher percentage such a 60% and more constitute a small fraction of the users."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.5 Change of e-books ratio over the years\n",
    "\n",
    "In the previous subpart, we observed a change of proportion among the proportion of users for a given e-books ratio with the years. We desire to analyze those variations more precisely."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 613,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Pre-computed data used for the latter plotting\n",
    "user_ratio_variations = spark.read.parquet(RESULT_FOLDER+\"user_ratio_variations.parquet\").toPandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define three categories of users:\n",
    "\n",
    "- __Small Kindle readers:__ ratios $[0\\%,25\\%]$ of e-books to the total numbers of books read\n",
    "- __Medium Kindle readers:__ ratios $[25\\%,75\\%]$ of e-books to the total numbers of books read\n",
    "- __Large Kindle readers:__ ratios $[75\\%,100\\%]$ of e-books to the total numbers of books read\n",
    "\n",
    "We then plot the number of users that remain or change their reading classes for each year as a sankey diagram."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 614,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8f929f66dc4c4caf87a6c309fec9da95",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "SankeyWidget(layout=Layout(height='800', width='1200'), links=[{'source': 'small:25%', 'target': '_', 'value':…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Sankey diagram plotting\n",
    "SankeyWidget(links=user_ratio_variations.to_dict('records'),layout = Layout(width=\"1200\", height=\"800\"), margins=dict(top=0, bottom=0, left=150, right=150))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pre-computed Sankey Diagram of User Ebooks Percentage Variation as a function of time ( compatiblity of the widget and display concerns )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Title](img/sankey.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can observe that __users tend to increase their relative consumption of e-books with the years__. However, it is mainly from the small to intermediate category. In addition, we observe that the number of __users reducing their Kindle consumption is relatively more important for the two last years__ transition. It could induce a resignation of the platform or a lesser interest for the support."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.6 User sentiment towards the Kindle\n",
    "\n",
    "As we observed in part 1.5, users seem to be less appealed to Kindle in proportion to classical books in the last years of the analysis. In order to have another point of view reagarding this matter, we analyze the other important component of the ratings i.e. the numerical grade in the range [1,5]. We decide to aggregate it per year, as the average difference in grades per user for the e-books minus the books rating grade. We compute this difference as a relative differenced normed by the maximal grade difference (i.e. $5-1=4$).\n",
    "\n",
    "$$yearly\\ difference\\ percentage = \\frac{\\textrm{AVG}_{year}(\\textrm{AVG}_{month,user}(ebooks\\ ratings) - \\textrm{AVG}_{month,user}(books\\ ratings))}{4}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 511,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+----------------------------------------------------+\n",
      "|Year|ebooks_rating_and_books_rating_difference_percentage|\n",
      "+----+----------------------------------------------------+\n",
      "|2008|                                -0.02450636032484...|\n",
      "|2009|                                -0.01518851117459626|\n",
      "|2010|                                -0.02020867969376...|\n",
      "|2011|                                -0.02172955927016...|\n",
      "|2012|                                -0.02194209314288...|\n",
      "|2013|                                -0.02455211950487068|\n",
      "|2014|                                -0.01798652640966...|\n",
      "+----+----------------------------------------------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "rating_diff = spark.sql(\"\"\"SELECT Year,  AVG(diff)/4.0 AS ebooks_rating_and_books_rating_difference_percentage\n",
    "            FROM\n",
    "            (SELECT User,\n",
    "                    Year,\n",
    "                    AVG(avg_kindle_rating) -\n",
    "                    AVG(avg_book_rating) AS diff\n",
    "             FROM kindle_proportion_time_factors\n",
    "             WHERE avg_kindle_rating > 0 AND avg_book_rating > 0\n",
    "             GROUP BY User, Year)\n",
    "             GROUP BY Year\n",
    "             ORDER BY Year\"\"\")\n",
    "rating_diff.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe that the __relative rating difference is not very marked__ (between 1.5% to 2.5%). Nonetheless, this bias is consistent given the years. This leads us to the second part of the project which consists of the user sentiment analysis in the reviews of the Kindle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 2 - Review texts analysis\n",
    "\n",
    "In order to make a more insightful analysis of the user opinion of the Kindle platform, we decide to use natural language processing techniques on the set of reviews. However, we desire to focus on the effect of the platform itself and not on the possible influence that the read book has on the review. We proceed in the following manner.\n",
    "\n",
    "1) We first use a Latent Dirichlet allocation (LDA) to determine if a \"technical\" Kindle topic is present in the reviews of the e-books. More precisely, we are looking for words such as \"format\", \"screen\", \"interactivity\", etc.\n",
    "\n",
    "2) We use a TF-IDF word weighting metric to validate that the words constituing the corpus of the technical topics are indeed more present in the e-books reviews corpus. \n",
    "\n",
    "3) Eventually, we use TextBlob to analyze the sentiment of reviews which contain the words of the technical topic and compare the results to those of the reviews missing these terms."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Latent Dirichlet allocation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.1 Loading stemmed corpus"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we load the corpus of previously stemmed (using `PorterStemmer` method from the `nltk` library) reviews. Stemming will prevent us from getting noise in our analysis from words having the same stem but being considered as different words (eg. wait, waited, waiting, ...).\n",
    "\n",
    "Unfortunately, for various performance reasons and to be able to perform all computations in a reasonable amount of time, we first limit ourselves to a corpus of 50k reviews."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rdd(filename, max_size = None):\n",
    "    df = spark.read.parquet(DATA_FOLDER + filename)\n",
    "    rdd = df.rdd.zipWithIndex().map(lambda r: (r[1], r[0][\"Words\"]))\n",
    "    return rdd if max_size == None else sc.parallelize(rdd.take(max_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "RDD_FILENAME = \"stemstem.parquet\"\n",
    "rdd = get_rdd(RDD_FILENAME, max_size = 50000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.2 Preparing the data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to use the `LDAModels` provided by `pyspark`, we need to shape the data. More precisely, we need to compute the number of occurrences of each term in each review. This is the purpose of the function `count_words` below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_words(rdd):\n",
    "    def word_occurrences(l):\n",
    "        counter = dict(Counter(l))\n",
    "        return list(zip(counter.keys(), counter.values()))\n",
    "    \n",
    "    return rdd.mapValues(word_occurrences)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we establish the set of all words present in our reviews. This is done in the `wordify` function below. `words` is constructed from iteratively taking the union of the set of words of each review. Finally, we assign to each word an unique integer index. This is going to be useful later..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wordify(rdd):\n",
    "    words = list(rdd.map(lambda p: set(p[1])).reduce(lambda x, y: x | y))\n",
    "    return dict([(words[i], i) for i in range(len(words))])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The last step of data preparation is to map the review of each entry of `rdd` to a vector of size `len(words)` containing at index $i$ the number of occurrences of word $i$. Since each review contains only a small subset of all possible words, we naturally choose a `SparseVector` instance for obvious performance reasons."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def LDAify(rdd, words):\n",
    "    return rdd.mapValues(lambda l: [(words[w], occurrences) for (w, occurrences) in l]).mapValues(lambda l: Vectors.sparse(len(words), dict(l))).map(lambda p: list(p))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Words can be computed in the following manner: `words = wordify(rdd)`. Nevertheless, since this computation is quite time consuming, we decided to do it once for all and to store the result in Pickle file. Hence, we load the dictionary as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = {}\n",
    "with open(RESULTS_FOLDER + \"words_lda.pickle\", 'rb') as handle:\n",
    "    words = pkl.load(handle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, we create the data matrix X:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = LDAify(count_words(rdd), words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.3 Core LDA analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LDA's `describeTopics()` method returns a list of `k` topics assigning to each one a word distribution. However, here words indices are used and not words themselves. Therefore, we implement the following `format_terms` function to help us retrieving a word from its index in `words`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def format_terms(indices, weights):\n",
    "    words_list = list(words)\n",
    "    return [(words_list[index], weights[i]) for (i, index) in enumerate(indices)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addition, it's worth noticing that LDA depends on two hyperparameters $\\alpha$ and $\\beta$, describing respectively the document and term distributions. We need to tune those parameters according to our needs and we do this using a simple grid search.\n",
    "\n",
    "This is what the `test_coefs` function below does. Also, it prints the topics created by the LDA so that we can manually evaluate their relevance to find the best values for $\\alpha$ and $\\beta$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_coefs():\n",
    "    res = []\n",
    "    for alpha in [1.01, 1.5, 2, 3]:\n",
    "        for beta in [1.01, 1.5, 2, 3]:\n",
    "            print(\"alpha = \" + str(alpha) + \" / beta = \" + str(beta))\n",
    "            lda = LDA(k = 10).setFeaturesCol(\"feature\").setMaxIter(100).setOptimizer(\"em\").setDocConcentration([float(alpha)]).setTopicConcentration(float(beta))\n",
    "            X_ = X.toDF([\"id\", \"feature\"])\n",
    "            model = lda.fit(X_)\n",
    "            res += [model.describeTopics().rdd.map(lambda r: (r[0], format_terms(r[1], r[2]))).take(10)]\n",
    "    \n",
    "    interesting_indices = []\n",
    "    for i in range(4):\n",
    "        for j in range(4):\n",
    "            for k, (_, words) in enumerate(res[4*i + j]):\n",
    "                if \"kindl\" in list(map(lambda p: p[0], words)):\n",
    "                    interesting_indices.append((4*i+j, k))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Chosen from above\n",
    "alpha = 2\n",
    "beta = 1.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Again, training a LDA model is quite time consuming. Therefore, we saved the model for the values $\\alpha = 1$ and $\\beta = 1.5$ in a Parquet file. Retrieving the model can be done as such:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "best_model = DistributedLDAModel.load(RESULTS_FOLDER + \"kindle_lda_model.parquet\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1.3 Topics extraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Topic 1\n",
      "    review: 1.669342772819849%\n",
      "    relationship: 1.227819401281716%\n",
      "    togeth: 1.1226048807265143%\n",
      "    into: 0.9942960889184277%\n",
      "    onli: 0.9100196149317308%\n",
      "    sexi: 0.8871170059162949%\n",
      "    she': 0.8252354260346444%\n",
      "    doesn't: 0.7530020812918945%\n",
      "    romanc: 0.7046308878346287%\n",
      "    passion: 0.5523344025810424%\n",
      "\n",
      "Topic 2\n",
      "    novel: 3.416132220056701%\n",
      "    mysteri: 3.056578227312123%\n",
      "    twist: 2.247111886674283%\n",
      "    suspens: 1.6679165260551003%\n",
      "    excel: 1.6058436532190203%\n",
      "    fiction: 1.342177967207062%\n",
      "    adventur: 1.2226281607025942%\n",
      "    murder: 1.1559497799029421%\n",
      "    humor: 1.138142625814316%\n",
      "    action: 0.9842488594565195%\n",
      "\n",
      "Topic 3\n",
      "    seri: 7.396401356429165%\n",
      "    becaus: 5.167379252584321%\n",
      "    author: 4.1938369866492335%\n",
      "    didn't: 3.359057931263465%\n",
      "    definit: 2.6682958127516434%\n",
      "    anoth: 1.8695779456988404%\n",
      "    onli: 1.6990315579187822%\n",
      "    couldn't: 1.6985199654105725%\n",
      "    wasn't: 1.6225247585990297%\n",
      "    disappoint: 1.4891925098047047%\n",
      "\n",
      "Topic 4\n",
      "    stori: 24.13733218636862%\n",
      "    veri: 13.017869695957318%\n",
      "    enjoy: 10.444317898409237%\n",
      "    realli: 9.958972710773846%\n",
      "    recommend: 5.357020154731531%\n",
      "    littl: 4.765993762500799%\n",
      "    nice: 2.193206484147389%\n",
      "    highli: 1.973553738057103%\n",
      "    anyon: 1.497580712747966%\n",
      "    funni: 1.2131688413462027%\n",
      "\n",
      "Topic 5\n",
      "    famili: 2.5475465671776814%\n",
      "    everi: 2.478906673827554%\n",
      "    alway: 2.4575039233391562%\n",
      "    peopl: 2.2524309454613447%\n",
      "    happi: 1.3430531129595868%\n",
      "    everyon: 1.2906349338901972%\n",
      "    beauti: 1.260775663027364%\n",
      "    away: 1.2437774689471053%\n",
      "    emot: 1.1176326825589522%\n",
      "    someon: 1.0368597686157324%\n",
      "\n",
      "Topic 6\n",
      "    kindl: 3.4851631644532497%\n",
      "    easi: 3.1347912851666506%\n",
      "    worth: 2.2031098890168312%\n",
      "    inform: 2.101707277234647%\n",
      "    recip: 1.4500934092009663%\n",
      "    edit: 1.2264422253445908%\n",
      "    purchas: 1.1451439387904845%\n",
      "    simpl: 1.1191543504478274%\n",
      "    price: 1.0908632820561763%\n",
      "    error: 0.907890172640072%\n",
      "\n",
      "Topic 7\n",
      "    vampir: 1.1504778828937832%\n",
      "    magic: 0.993768653922828%\n",
      "    onli: 0.9475194464188865%\n",
      "    tale: 0.9119911057497841%\n",
      "    into: 0.7379412586360928%\n",
      "    becom: 0.6391268411779106%\n",
      "    evil: 0.6035439353139294%\n",
      "    dragon: 0.5272237515241361%\n",
      "    discov: 0.527087217235157%\n",
      "    forc: 0.520361319889943%\n",
      "\n",
      "Topic 8\n",
      "    charact: 7.916609945957475%\n",
      "    stori: 3.594943391212361%\n",
      "    reader: 2.3783095049921688%\n",
      "    into: 2.098875026784556%\n",
      "    author: 1.9831345959347724%\n",
      "    plot: 1.8636880414413062%\n",
      "    romanc: 1.6224680971677397%\n",
      "    scene: 1.1354941044048612%\n",
      "    origin: 1.0590461834987939%\n",
      "    review: 0.9305601102007053%\n",
      "\n",
      "Topic 9\n",
      "    mani: 1.393466337031174%\n",
      "    author: 1.2858657692254476%\n",
      "    understand: 1.1108965844667746%\n",
      "    peopl: 0.8453844245874245%\n",
      "    histori: 0.7528662945217954%\n",
      "    experi: 0.7524499625790269%\n",
      "    provid: 0.6337621058969057%\n",
      "    import: 0.6065805632512865%\n",
      "    explain: 0.5723827834142591%\n",
      "    into: 0.5668916533328499%\n",
      "\n",
      "Topic 10\n",
      "    can't: 10.611228797169789%\n",
      "    amaz: 4.718290448975991%\n",
      "    excit: 3.380731389981123%\n",
      "    awesom: 2.9894766053689388%\n",
      "    jack: 1.865220437126645%\n",
      "    zombi: 1.0136067964718347%\n",
      "    david: 0.9745608895211382%\n",
      "    super: 0.9134112272977353%\n",
      "    till: 0.6307585033674608%\n",
      "    chri: 0.6198056802175024%\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def print_topics(model, dictionary):\n",
    "    words_list = list(dictionary)\n",
    "    for i, words in model.describeTopics(10).rdd.map(lambda r: (r[0], (zip(r[1], r[2])))).groupByKey().sortByKey().collect():\n",
    "        print(\"Topic \" + str(i+1))\n",
    "        for word_indices in words:\n",
    "            for word, per in (map(lambda w: (words_list[w[0]], w[1]), word_indices)):\n",
    "                print(\"    \" + word + \": \" + str(100*per) + \"%\")\n",
    "        print()\n",
    "\n",
    "print_topics(best_model, words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the topics displayed above, we note that a large number of them seem related to specific genres that we might find in books. For example, the topic containing \"relationship\", \"together\", \"sexi\", \"romanc\", \"passion\" may be a genre that we could call \"Love & Romance\".\n",
    "\n",
    "However, __a specific topic has retained our whole attention. It is topic number 6, essentially containing words that are really specific to Kindle features__."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 TF-IDF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We know from the LDA analysis above that users talk about the Kindle and its technology in their reviews. Now we wish to target those reviews. For this, we need to extract their specific words.\n",
    "\n",
    "In order to achieve this, we will use the TF-IDF method, allowing us to extract words specific to the Kindle reviews and we will keep only the ones which are related to technology or the Kindle in general.\n",
    "\n",
    "The code and experiments to extract the words are located in `tfidf.py`. The recovery of the words was a laborious task, we extracted the 100 most specific words which appears once every $10^6$ reviews, then once every $10^5$ reviews and so on until the words that appear once every $10^3$ reviews. Hence we are not going to display the full detail of this analysis, but rather the results we found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hardcoded results in a dictionary\n",
    "words = [\"charger\", \"paperwhit\", \"headphone\", \"warranti\", \"e-ink\", \"well-format\",\\\n",
    "         \"recharge\", \"tablet\", \"kindl\", \"ebook\", \"e-read\",\\\n",
    "          \"download\", \"screen\", \"device\", \"easi\", \"complaint\", \"price\", \\\n",
    "          \"disappoint\", \"worth\", \"recommend\", \"hate\"]\n",
    "values = [1.965, 1.940, 1.883, 1.877, 1.777, 1.775, 1.600, 1.587, 1.574, 1.551, 1.535, \\\n",
    "          1.460, 1.437, 1.324, 1.312, 1.307, 1.289, 1.280, 1.260, 1.241, 1.187]\n",
    "df_total = pd.DataFrame({\"Words\" : words, \"TF-IDF values\" : values})\n",
    "len(words)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We found a nice gradient of colors on http://colorbrewer2.org/#type=sequential&scheme=PuBuGn&n=4 that allows us to display our results in a nice fashion.\n",
    "\n",
    "Then we will display the results on two rows for the sake of readibility."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 584,
   "metadata": {},
   "outputs": [],
   "source": [
    "def highlighting(s):\n",
    "    e = s[0]\n",
    "    if e < 1.2:\n",
    "        return ['background-color: #d7191c']\n",
    "    elif e < 1.4:\n",
    "        return ['background-color: #fdae61']\n",
    "    elif e < 1.6:\n",
    "        return ['background-color: #ffffbf']\n",
    "    elif e < 1.8:\n",
    "        return ['background-color: #a6d96a']\n",
    "    else:\n",
    "        return ['background-color: #1a9641']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 585,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col0 {\n",
       "            background-color:  #1a9641;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col1 {\n",
       "            background-color:  #1a9641;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col2 {\n",
       "            background-color:  #1a9641;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col3 {\n",
       "            background-color:  #1a9641;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col4 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col5 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col6 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col7 {\n",
       "            background-color:  #ffffbf;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col8 {\n",
       "            background-color:  #ffffbf;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col9 {\n",
       "            background-color:  #ffffbf;\n",
       "        }    #T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col10 {\n",
       "            background-color:  #ffffbf;\n",
       "        }</style>  \n",
       "<table id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7c\" > \n",
       "<thead>    <tr> \n",
       "        <th class=\"blank level0\" ></th> \n",
       "        <th class=\"col_heading level0 col0\" >charger</th> \n",
       "        <th class=\"col_heading level0 col1\" >paperwhit</th> \n",
       "        <th class=\"col_heading level0 col2\" >headphone</th> \n",
       "        <th class=\"col_heading level0 col3\" >warranti</th> \n",
       "        <th class=\"col_heading level0 col4\" >e-ink</th> \n",
       "        <th class=\"col_heading level0 col5\" >well-format</th> \n",
       "        <th class=\"col_heading level0 col6\" >recharge</th> \n",
       "        <th class=\"col_heading level0 col7\" >tablet</th> \n",
       "        <th class=\"col_heading level0 col8\" >kindl</th> \n",
       "        <th class=\"col_heading level0 col9\" >ebook</th> \n",
       "        <th class=\"col_heading level0 col10\" >e-read</th> \n",
       "    </tr></thead> \n",
       "<tbody>    <tr> \n",
       "        <th id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7clevel0_row0\" class=\"row_heading level0 row0\" >0</th> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col0\" class=\"data row0 col0\" >1.965</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col1\" class=\"data row0 col1\" >1.94</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col2\" class=\"data row0 col2\" >1.883</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col3\" class=\"data row0 col3\" >1.877</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col4\" class=\"data row0 col4\" >1.777</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col5\" class=\"data row0 col5\" >1.775</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col6\" class=\"data row0 col6\" >1.6</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col7\" class=\"data row0 col7\" >1.587</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col8\" class=\"data row0 col8\" >1.574</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col9\" class=\"data row0 col9\" >1.551</td> \n",
       "        <td id=\"T_c3bc9d46_00a1_11e9_bcb5_985aeb8c6e7crow0_col10\" class=\"data row0 col10\" >1.535</td> \n",
       "    </tr></tbody> \n",
       "</table> "
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x1a2ce05438>"
      ]
     },
     "execution_count": 585,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_ = {}\n",
    "for i in range(11):\n",
    "    dict_[words[i]] = [values[i]]\n",
    "df_dict = pd.DataFrame(dict_)\n",
    "df_dict.style.apply(highlighting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 586,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col0 {\n",
       "            background-color:  #ffffbf;\n",
       "        }    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col1 {\n",
       "            background-color:  #ffffbf;\n",
       "        }    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col2 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col3 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col4 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col5 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col6 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col7 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col8 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col9 {\n",
       "            background-color:  #d7191c;\n",
       "        }</style>  \n",
       "<table id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7c\" > \n",
       "<thead>    <tr> \n",
       "        <th class=\"blank level0\" ></th> \n",
       "        <th class=\"col_heading level0 col0\" >download</th> \n",
       "        <th class=\"col_heading level0 col1\" >screen</th> \n",
       "        <th class=\"col_heading level0 col2\" >device</th> \n",
       "        <th class=\"col_heading level0 col3\" >easi</th> \n",
       "        <th class=\"col_heading level0 col4\" >complaint</th> \n",
       "        <th class=\"col_heading level0 col5\" >price</th> \n",
       "        <th class=\"col_heading level0 col6\" >disappoint</th> \n",
       "        <th class=\"col_heading level0 col7\" >worth</th> \n",
       "        <th class=\"col_heading level0 col8\" >recommend</th> \n",
       "        <th class=\"col_heading level0 col9\" >hate</th> \n",
       "    </tr></thead> \n",
       "<tbody>    <tr> \n",
       "        <th id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7clevel0_row0\" class=\"row_heading level0 row0\" >0</th> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col0\" class=\"data row0 col0\" >1.46</td> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col1\" class=\"data row0 col1\" >1.437</td> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col2\" class=\"data row0 col2\" >1.324</td> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col3\" class=\"data row0 col3\" >1.312</td> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col4\" class=\"data row0 col4\" >1.307</td> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col5\" class=\"data row0 col5\" >1.289</td> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col6\" class=\"data row0 col6\" >1.28</td> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col7\" class=\"data row0 col7\" >1.26</td> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col8\" class=\"data row0 col8\" >1.241</td> \n",
       "        <td id=\"T_c44d2226_00a1_11e9_a960_985aeb8c6e7crow0_col9\" class=\"data row0 col9\" >1.187</td> \n",
       "    </tr></tbody> \n",
       "</table> "
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x1a2e710780>"
      ]
     },
     "execution_count": 586,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict2_ = {}\n",
    "for i in range(11, len(words)):\n",
    "    dict2_[words[i]] = [values[i]]\n",
    "df_dict2 = pd.DataFrame(dict2_)\n",
    "df_dict2.style.apply(highlighting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thanks to this analysis, we are able to target Kindle-specific words which are about technology. In the results displayed, a color and a number is associated to each word. A color close to green and a number close to 2 denotes a very specific word, i.e a number that appears twice more often in the Kindle corpus than in the Books one. At the other side of the gradient, a color close to red and a value close to one denotes a not very specific word. A word with a value of 1 appears exactly the same number of times in the two corpuses.\n",
    "\n",
    "Those words will help us target the technology-specific reviews about the Kindle in the next step of our analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Sentiment analysis using TextBlob"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the two previous steps, we were able to determine that there was a meaningful technical topic in the Kindle reviews. We now proceed to a sentiment analysis with the help of the TextBlob library which yields results in the range [-1,1] given a piece of text, where -1 being extremly negative sentiment, 1 very positive and 0 neutral. We perform the analysis on the set of reviews for the frequent readers from part 1 to keep a consistency throughout the project. We split the dataset into technical and non-technical reviews depending on whether the review text contains words from the previously defined technical topic dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 553,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Loading of the reduced kindle reviews corresponding to the reviews left by the frequent books and ebooks readers population\n",
    "df_reduced_reviews_kindle = spark.read.parquet(RESULT_FOLDER+'kindle_reduced_review_year.parquet')\n",
    "df_reduced_reviews_kindle.registerTempTable(\"df_reduced_reviews_kindle\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Defintion of the technical dictionnary\n",
    "dictionary = ['kindl',\n",
    "              'inform',\n",
    "              'easi',\n",
    "              'worth',\n",
    "              'purchas',\n",
    "              'chapter',\n",
    "              'price',\n",
    "              'edit',\n",
    "              'writer',\n",
    "              'error',\n",
    "              'ebook',\n",
    "              'easi',\n",
    "              'version',\n",
    "              'e-ink',\n",
    "              'well-format',\n",
    "              'e-read',\n",
    "              'screen',\n",
    "              'device',\n",
    "              'complaint',\n",
    "              'display',\n",
    "              'layout',\n",
    "              'format',\n",
    "              'annot',\n",
    "              'interactiv']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We decide to use SnowballStemmer this time because it has the advantage to take as parameter a language which improves on the quality of the stemming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "stemmer = SnowballStemmer(\"english\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 557,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We stem, then filter reviews to keep only those that contains a word present in the dictionnary. Eventually we join the\n",
    "#stemmed words constituing the reviews into a sentence from which we quantify the sentiment with TextBlob\n",
    "df_kindle_filtered = df_reduced_reviews_kindle.rdd.map(lambda row: (row.year, row.reviewText.split(\" \"))).map(lambda row: (row[0],[stemmer.stem(word) for word in row[1]])).filter(lambda row: any(word in row[1] for word in dictionary)).map(lambda row: (row[0], \" \".join(row[1]))).toDF()\n",
    "df_kindle_filtered.write.parquet(RESULT_FOLDER+\"kindle_reviews_textblob.parquet\")\n",
    "df_kindle_filtered = spark.read.parquet(RESULT_FOLDER+\"kindle_reviews_textblob.parquet\")\n",
    "df_kindle_filtered.registerTempTable(\"df_kindle_filtered\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 560,
   "metadata": {},
   "outputs": [],
   "source": [
    "#We do the same process as explained above but on the reviews that do not contain a technical aspect in their words\n",
    "df_reviews_stemmed = df_reviews_kindle.rdd.map(lambda row: (row.year, row.reviewText.split(\" \"))).map(lambda row: (row[0],[stemmer.stem(word) for word in row[1]])).map(lambda row: (row[0], \" \".join(row[1]))).toDF()\n",
    "df_reviews_stemmed.registerTempTable(\"df_reviews_stemmed\")\n",
    "df_difference_reviews = spark.sql(\"\"\"(SELECT * \n",
    "                                      FROM df_reviews_stemmed)\n",
    "                                      MINUS\n",
    "                                      (SELECT _2 AS reviewText, _1 AS year\n",
    "                                      FROM df_kindle_filtered)\"\"\")\n",
    "\n",
    "df_difference_reviews.write.parquet(RESULT_FOLDER+\"kindle_difference_reviews_filtered.parquet\")\n",
    "df_difference_reviews = spark.read.parquet(RESULT_FOLDER+\"kindle_difference_reviews_filtered.parquet\")\n",
    "df_blob = df_kindle_filtered.rdd.map(lambda row: (row._1,TextBlob(row._2).sentiment.polarity)).toDF()\n",
    "df_blob_difference = df_difference_reviews.rdd.map(lambda row: (row._1,TextBlob(row._2).sentiment.polarity)).toDF()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 561,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Registration of tables for SQL queries\n",
    "df_blob.registerTempTable(\"df_blob\")\n",
    "df_blob_difference.registerTempTable(\"df_blob_difference\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 581,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+-------------------+-------------------+--------------+\n",
      "|Year|            average|                std|number_reviews|\n",
      "+----+-------------------+-------------------+--------------+\n",
      "|2008|0.19170204075339695|0.13930735327609967|           162|\n",
      "|2009|0.19735687523836762|0.17213023912167863|           349|\n",
      "|2010| 0.1832341597207311|  0.135431797834834|          1464|\n",
      "|2011|0.18609293900605972|0.13969769121661657|          8424|\n",
      "|2012|0.20783973016559112|0.17055396160778094|         36739|\n",
      "|2013|0.22910094529968664|0.19675157240674276|        101647|\n",
      "|2014|0.23284503606947587|0.19219510432923484|         92805|\n",
      "+----+-------------------+-------------------+--------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Techincal reviews TextBlob stats\n",
    "df_blob_stat = spark.sql(\"\"\"SELECT _1 AS Year, AVG(_2) as average, STD(_2) AS std, COUNT(_2) AS number_reviews\n",
    "             FROM df_blob\n",
    "             GROUP BY Year\n",
    "             ORDER BY Year\n",
    "             \"\"\")\n",
    "df_blob_stat.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 582,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----+-------------------+-------------------+--------------+\n",
      "|Year|            average|                std|number_reviews|\n",
      "+----+-------------------+-------------------+--------------+\n",
      "|2008|0.21131292414251338|0.15271562128145633|           575|\n",
      "|2009|0.20178328012244898|0.15777446571937237|          1001|\n",
      "|2010| 0.2011067234320961|0.15131877988800102|          4460|\n",
      "|2011|0.19909737987842907| 0.1652592104606844|         24951|\n",
      "|2012|0.22477877980356284| 0.1942601404685062|        121556|\n",
      "|2013| 0.2496009341882106|0.22050814490666107|        449528|\n",
      "|2014| 0.2532085213393239|0.21803204738055204|        428195|\n",
      "+----+-------------------+-------------------+--------------+\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Non-Techincal reviews TextBlob stats\n",
    "df_blob_difference_stat = spark.sql(\"\"\"SELECT _1 AS Year, AVG(_2) as average, STD(_2) AS std, COUNT(_2) AS number_reviews\n",
    "             FROM df_blob_difference\n",
    "             GROUP BY Year\n",
    "             ORDER BY Year\"\"\")\n",
    "df_blob_difference_stat.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 588,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df_blob_stats_pandas = df_blob_stat.toPandas()\n",
    "df_blob_difference_stat_pandas = df_blob_difference_stat.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 589,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Plotting of the two curves\n",
    "years = df_blob_stats_pandas['Year'].values\n",
    "\n",
    "technical = df_blob_stats_pandas['average'].values\n",
    "non_technical = df_blob_difference_stat_pandas['average'].values\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "fig.set_size_inches(12, 6)\n",
    "plt.title(\"Average TextBlob sentiment as a function of the year\")\n",
    "ax.plot(years,technical, label='technical aspect present')\n",
    "ax.plot(years,non_technical, label='technical aspect not present')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe that the __reviews containing the technical aspects have consistently a lower average TextBlob score than the non-technical reviews__ which leads us to think that the Kindle support indeed has a negative impact on the user appreciation of the support. However we need to statistically confirm this hypothesis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4 Statistical validation Tests"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this final subpart we perform two statistical tests to check the validity of our previous hypothesis.\n",
    "\n",
    "1) p-values for each year\n",
    "\n",
    "2) t-test for the whole\n",
    "\n",
    "In order to do so, we first plot the relative distribution of the TextBlob scores to ensure that those follow normal distribution, for the tests to be applicable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 563,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Conversion to Pandas dataframe of the dataframes\n",
    "df_blob_pandas = df_blob.toPandas()\n",
    "df_blob_difference_pandas = df_blob_difference.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 575,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "n, bins, patches = ax.hist(df_blob_pandas['_2'].values, bins=200,  weights=np.zeros_like(df_blob_pandas['_2'].values) + 1. / df_blob_pandas['_2'].values.size, cumulative=0)\n",
    "ax.set_title(\"Distribution of the TextBlob Sentiment for Kindle Reviews Including Technical Aspect\")\n",
    "ax.set_xlabel('TextBlob Sentiment', size=10)\n",
    "ax.set_ylabel('Frequency', size=10)\n",
    "fig.set_size_inches((20,10))\n",
    "ax.legend\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 576,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.add_subplot(111)\n",
    "n, bins, patches = ax.hist(df_blob_difference_pandas['_2'].values, bins=200,  weights=np.zeros_like(df_blob_difference_pandas['_2'].values) + 1. / df_blob_difference_pandas['_2'].values.size, cumulative=0)\n",
    "ax.set_title(\"Distribution of the TextBlob Sentiment for Kindle Reviews Without Technical Aspect\")\n",
    "ax.set_xlabel('TextBlob Sentiment', size=10)\n",
    "ax.set_ylabel('Frequency', size=10)\n",
    "fig.set_size_inches((20,10))\n",
    "ax.legend\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Excepting some outliers for the value around 0 which concludes to a neutral review and are mostly due to the limitation of the algorithm used by TextBlob, __we confirm that the distributions are Gaussian normal__. We can therefore apply the two tests mentionned above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.1 p-value computation\n",
    "\n",
    "Here we remove the dust from the probability and statistics notebooks to compute a precise p-value to evaluate the probability that the sentiment analysis for the technical reviews have the same distribution that the sentiment analysis for the non-technical ones.\n",
    "\n",
    "Let's call $T \\sim \\mathcal{N}(\\mu_T, \\sigma_T)$ the distribution of the sentiment for one technical review and $O \\sim \\mathcal{N}(\\mu_O, \\sigma_O)$ the distribution of the sentiment for one non-technical review.\n",
    "\n",
    "Then we define $A = \\frac{1}{N} \\sum_{i=1}^N T_i \\sim \\mathcal{N}(\\mu_A, \\sigma_A)$.\n",
    "\n",
    "Hence our hypothesis $H_0$ and $H_1$ will be :\n",
    "\n",
    "$H_0$ : $A$ has the same distribution as $O$.\n",
    "\n",
    "$H_1$ : $A$ and $O$ do not have the same distribution.\n",
    "\n",
    "##### Under assumption $H_0$\n",
    "\n",
    "$$\\mu_A = \\frac{1}{N} \\sum_{i=1}^N \\mathbb{E}[T_i] = \\mu_T = \\mu_O$$\n",
    "\n",
    "$$\\sigma_A^2 = \\frac{1}{N^2}\\sum_{i=1}^N Var[T_i] = \\frac{\\sigma_T^2}{N} = \\frac{\\sigma_O^2}{N}$$\n",
    "\n",
    "we then compute the probability that under those assumptions, we obtain a value of $A$ less or equal to the value of $\\mu_T$ we observed.\n",
    "\n",
    "\\begin{align}\n",
    "\\mathbb{P}(A \\leq \\mu_T | H_0) &= 1 - \\mathbb{P}(A > \\mu_T | H_0)\\\\\n",
    "&= 1 - \\mathbb{P}\\left(\\frac{A - \\mu_0}{\\sqrt{\\frac{\\sigma_0^2}{N}}}  > \\frac{\\sqrt{N}(\\mu_T - \\mu_0)}{\\sigma_0}\\right)\\\\\n",
    "&= 1 - \\mathbb{P}\\left(Z > \\frac{\\sqrt{N}(\\mu_T - \\mu_0)}{\\sigma_0}\\right)\\\\\n",
    "&= 1 - \\mathcal{Q}\\left(\\frac{\\sqrt{N}(\\mu_T - \\mu_0)}{\\sigma_0}\\right)\n",
    "\\end{align}\n",
    "\n",
    "Where $Z \\sim \\mathcal{N}(0, 1)$, and $\\mathcal{Q}(x) = \\mathbb{P}(Z > x)$ is the tail distribution function of the standard normal distribution.\n",
    "\n",
    "Hence we have our p-value :\n",
    "\n",
    "$$p-value = 1 - \\mathcal{Q}\\left(\\frac{\\sqrt{N}(\\mu_T - \\mu_0)}{\\sigma_0}\\right)$$\n",
    "\n",
    "We compute it for the years 2008 - 2014 :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p-values for hypothesis H0 over the years :\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col0 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col1 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col2 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col3 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col4 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col5 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col6 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col0 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col1 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col2 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col3 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col4 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col5 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col6 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col0 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col1 {\n",
       "            background-color:  #fdae61;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col2 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col3 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col4 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col5 {\n",
       "            background-color:  #a6d96a;\n",
       "        }    #T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col6 {\n",
       "            background-color:  #a6d96a;\n",
       "        }</style>  \n",
       "<table id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556\" > \n",
       "<thead>    <tr> \n",
       "        <th class=\"blank level0\" ></th> \n",
       "        <th class=\"col_heading level0 col0\" >2008</th> \n",
       "        <th class=\"col_heading level0 col1\" >2009</th> \n",
       "        <th class=\"col_heading level0 col2\" >2010</th> \n",
       "        <th class=\"col_heading level0 col3\" >2011</th> \n",
       "        <th class=\"col_heading level0 col4\" >2012</th> \n",
       "        <th class=\"col_heading level0 col5\" >2013</th> \n",
       "        <th class=\"col_heading level0 col6\" >2014</th> \n",
       "    </tr></thead> \n",
       "<tbody>    <tr> \n",
       "        <th id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556level0_row0\" class=\"row_heading level0 row0\" >p-value</th> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row0_col0\" class=\"data row0 col0\" >0.0512</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row0_col1\" class=\"data row0 col1\" >0.3012</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row0_col2\" class=\"data row0 col2\" >3e-06</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row0_col3\" class=\"data row0 col3\" >2.63e-13</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row0_col4\" class=\"data row0 col4\" >2.01e-63</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row0_col5\" class=\"data row0 col5\" >2.22e-193</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row0_col6\" class=\"data row0 col6\" >4.73e-179</td> \n",
       "    </tr>    <tr> \n",
       "        <th id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556level0_row1\" class=\"row_heading level0 row1\" >0.1 confidence</th> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col0\" class=\"data row1 col0\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col1\" class=\"data row1 col1\" >✗</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col2\" class=\"data row1 col2\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col3\" class=\"data row1 col3\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col4\" class=\"data row1 col4\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col5\" class=\"data row1 col5\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row1_col6\" class=\"data row1 col6\" >✓</td> \n",
       "    </tr>    <tr> \n",
       "        <th id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556level0_row2\" class=\"row_heading level0 row2\" >0.01 confidence</th> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col0\" class=\"data row2 col0\" >✗</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col1\" class=\"data row2 col1\" >✗</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col2\" class=\"data row2 col2\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col3\" class=\"data row2 col3\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col4\" class=\"data row2 col4\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col5\" class=\"data row2 col5\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row2_col6\" class=\"data row2 col6\" >✓</td> \n",
       "    </tr>    <tr> \n",
       "        <th id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556level0_row3\" class=\"row_heading level0 row3\" >0.001 confidence</th> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col0\" class=\"data row3 col0\" >✗</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col1\" class=\"data row3 col1\" >✗</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col2\" class=\"data row3 col2\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col3\" class=\"data row3 col3\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col4\" class=\"data row3 col4\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col5\" class=\"data row3 col5\" >✓</td> \n",
       "        <td id=\"T_fc1abb4a_ffda_11e8_b148_548ca034d556row3_col6\" class=\"data row3 col6\" >✓</td> \n",
       "    </tr></tbody> \n",
       "</table> "
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x7f808fe37358>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "def highlighting(s):\n",
    "    if s == u'\\u2713':\n",
    "        return 'background-color: #a6d96a'\n",
    "    elif s == u'\\u2717':\n",
    "        return 'background-color: #fdae61'\n",
    "    return ''\n",
    "\n",
    "dict_ = {\n",
    "    \"2008\" : [0.0512, u'\\u2713', u'\\u2717', u'\\u2717'],\n",
    "    \"2009\" : [0.3012, u'\\u2717', u'\\u2717', u'\\u2717'],\n",
    "    \"2010\" : [3e-6, u'\\u2713', u'\\u2713', u'\\u2713'],\n",
    "    \"2011\" : [2.63e-13, u'\\u2713', u'\\u2713', u'\\u2713'],\n",
    "    \"2012\" : [2.01e-63, u'\\u2713', u'\\u2713', u'\\u2713'],\n",
    "    \"2013\" : [2.22e-193, u'\\u2713', u'\\u2713', u'\\u2713'],\n",
    "    \"2014\" : [4.73e-179, u'\\u2713', u'\\u2713', u'\\u2713']}\n",
    "\n",
    "rows_names = {0:\"p-value\", 1:\"0.1 confidence\", 2:\"0.01 confidence\", 3:\"0.001 confidence\"}\n",
    "\n",
    "print(\"p-values for hypothesis H0 over the years :\")\n",
    "df = pd.DataFrame(dict_)\n",
    "df = df.rename(index=rows_names)\n",
    "df.style.applymap(highlighting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__The p-value for the hypothesis $H_0$ is way less than 0.001 for all the years > 2009__. We even reach p-values that can be considered as null after 2012.\n",
    "\n",
    "We can still notice a special result in 2009 where the p-value is 0,3012. However, computing the the p-value the other way around (considering that the distribution of the sentiment of the technical aspects is the one we computed) also give us a high p-value of 0,3165."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2.4.2 t-test\n",
    "\n",
    "Since the sizes of the two datasets are several orders of magnitude apart given the year, we decide to perform an additional t-test statistic in a time-invariant setting (all years confoud) and from which we sample the same amount of datapoints to make sure that the previous test is suitable. We choose 10k points since this value allows us to approximate the $t_{df,\\alpha}$ by the normal law distribution values. In addition, before sampling we remove the outliers i.e. values with TextBlob score equal to 0.\n",
    "\n",
    "We use the following formula to compute the t-value:\n",
    "\n",
    "$$t = \\frac{M_{non\\ tech}-M_{tech}}{\\sqrt{ \\frac{Var_{non\\ tech}}{n_{non\\ tech}} + \\frac{Var_{tech}}{n_{tech}} }}$$\n",
    "\n",
    "Where:\n",
    "\n",
    "- $M_{tech}$: the empirical mean for reviews including technical aspect\n",
    "- $M_{non\\ tech}$: the empirical mean for reviews not including technical aspect\n",
    "- $Var_{tech}$: the empircal variance for reviews including technical aspect\n",
    "- $Var_{non\\ tech}$: the empircal variance for reviews not including technical aspect\n",
    "- $n_{tech}$: the number of samples for reviews including technical aspect\n",
    "- $n_{non\\ tech}$: the number of samples for reviews not including technical aspect\n",
    "\n",
    "In our case the to last quantities are the same and equal to 10'000."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 605,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Sampling after \n",
    "df_blob_pandas_sample = df_blob_pandas[df_blob_pandas._2 != 0].sample(n = 10000)\n",
    "df_blob_difference_pandas_sample = df_blob_difference_pandas[df_blob_difference_pandas._2 != 0].sample(n = 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 603,
   "metadata": {},
   "outputs": [],
   "source": [
    "m_tech = np.mean(df_blob_pandas_sample['_2'].values)\n",
    "m_non_tech = np.mean(df_blob_difference_pandas_sample['_2'].values)\n",
    "var_tech = np.var(df_blob_pandas_sample['_2'].values)\n",
    "var_non_tech = np.var(df_blob_difference_pandas_sample['_2'].values)\n",
    "n = 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 604,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.000461138723196"
      ]
     },
     "execution_count": 604,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = (m_non_tech-m_tech)/np.sqrt((var_tech/n)+(var_non_tech/n))\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe a large t-value which confidently confirms that there is a statistical difference in between the distributions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hence we conclude that we can safely __reject the null hypothesis__ and consequently that __the distribution of the sentiment for reviews about the technical aspect of the Kindle is not distributed the same way as the one for the reviews about the non-technical aspects__. Although this difference is tiny, it is noticeable and not due to randomness."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Part 3 - Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Kindle is a highly advertised product by Amazon that releases upgrades of the device very often and pushes it towards its customers by placing it on the frontpage of its store. It is to the world of books what the iPod was to the world of music. A brand new way to read, allowing the users to pack multiple books within the same device and its numerical format makes it very convenient to use! No more bookmarks are needed, the Kindle remembers where you stopped reading for you! You can read in the dark without a torch, and much more...\n",
    "\n",
    "However, it is interesting to wonder whether the public has actually received the product as it had been designed. The Kindle falls within the context of a quickly changing world, where single devices can now accomplish much more than before, they make our lives easier, with the drawbacks that we all know. Furthermore, the Human Kind has been writing and reading for centuries, now. The Kindle aims to modernize the way people live with this old tradition. We seek to understand whether and how this new tool is welcomed in our lives.\n",
    "\n",
    "In part 1.1, we see that the Kindle appeals to a lot of users who give it a try and its popularity is important given its several orders smaller catalog compared to classical physical books. The Kindle has effectively taken a share in the percentage of the books read by frequent users. Its growth was important and represented 1 out of 4 books at the last year. The effect of the Kindle was not a increase in the overall number of read books but a replacement of the format for a fraction of those. \n",
    "\n",
    "Parts 1.[2, 3, 4] show that frequent readers seem not to totally switch to this new form of reading. We see that in general, they continue to consume traditional good old paper books as well, it appears they are not quite ready to jump ahead. In addition, as seen in part 1.5, in the last years (of the available data) users seem to make a strong come back to the classical way of reading abandoning the platform in favor of the physical offer. This can interpreted with the recent trend among younger generations who re-discover old supports and favorize them as in the case of books, as explained in the document below. Finally, part 1.6, shows that reviews are slightly better (approx. 2%) for traditional books compared to Kindle every year.\n",
    "\n",
    "_Ebook sales continue to fall as younger generations drive appetite for print_, the Guardian, Sian Cain,14.03.2017,  https://www.theguardian.com/books/2017/mar/14/ebook-sales-continue-to-fall-nielsen-survey-uk-book-sales\n",
    "\n",
    "The second part of our analysis shows that reviews mentioning terms that are specific to Kindle's technical aspect tend to be a little worse than the others. Even though the difference is small, we confirmed this trend with statistical tests that gave a good confidence level of our affirmation. Hence the Kindle-specific aspects appears not to be the main reason why custommers actually buy Kindle products.\n",
    "\n",
    "In conclusion, we see that people like the Kindle in general. Many many people have tried it, almost nobody definitively adopted it but the pool of users tends to remain similar over the last years. However, in contrast to what we might have thought in the prior, these are not the features that are specific to the Kindle itself that appeal users the most. It looks like the Human Kind is not ready to give up traditional paper books for now, although the Kindle is an interesting alternative to reading books."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:anaconda3]",
   "language": "python",
   "name": "conda-env-anaconda3-py"
  },
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}