Jupyter/M04-DataManipulation/M04H-CS-WordCount.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "h_ezb8ayhHjS"
   },
   "source": [
    "![Cloud-First](../image/CloudFirst.png) \n",
    "\n",
    "\n",
    "# SIT742: Modern Data Science \n",
    "**(Module: Big Data Manipulation)**\n",
    "\n",
    "---\n",
    "- Materials in this module include resources collected from various open-source online repositories.\n",
    "- You are free to use, change and distribute this package.\n",
    "- If you found any issue/bug for this document, please submit an issue at [tulip-lab/sit742](https://github.com/tulip-lab/sit742/issues)\n",
    "\n",
    "\n",
    "Prepared by **SIT742 Teaching Team**\n",
    "\n",
    "---\n",
    "\n",
    "\n",
    "## Session 4H: Case Study - Word Count Application\n",
    "---\n",
    "\n",
    "This lab will build on the techniques covered in the Spark tutorial to develop a simple word count application.  The volume of unstructured text in existence is growing dramatically, and Spark is an excellent tool for analyzing this type of data.  In this lab, we will write code that calculates the most common words in the [Complete Works of William Shakespeare](http://www.gutenberg.org/ebooks/100) retrieved from [Project Gutenberg](http://www.gutenberg.org/wiki/Main_Page).  This could also be scaled to find the most common words on the Internet. \n",
    "\n",
    "Note that, for reference, you can look up the details of the relevant methods in [Spark's Python API](https://spark.apache.org/docs/latest/api/python/pyspark.html#pyspark.RDD)\n",
    "\n",
    "In this lab session, we also provide the method how to test your code using the third-party package test_helper. However, it cannot work on the Google colab environment. If you would like, you can try them on the Anaconda Jupyter notebook or your local python environment.\n",
    "\n",
    "\n",
    "### Content\n",
    "\n",
    "* [Creating a base RDD and pair RDDs](#baserdds)\n",
    "\n",
    "* [Counting with pair RDDs](#pairrdds)\n",
    "\n",
    "* [Finding unique words and a mean value](#find)\n",
    "\n",
    "* [Apply word count to a file](#count)\n",
    "\n",
    "---\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2SSgwK8LhHjT"
   },
   "source": [
    "<a id = \"baserdds\"></a>\n",
    "## 1. Creating a base RDD and pair RDDs "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kLI9FmC4hHjV"
   },
   "source": [
    "In this part of the lab, we will explore creating a base RDD with `parallelize` and using pair RDDs to count words."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Mk998VAVhHjW"
   },
   "source": [
    "#### ** (1a) Create a base RDD **\n",
    "\n",
    "We'll start by generating a base RDD by using a Python list and the `sc.parallelize` method.  Then we'll print out the type of the base RDD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "RGRJyic8kxbf"
   },
   "outputs": [],
   "source": [
    "!apt-get update\n",
    "!apt-get install openjdk-8-jdk-headless -qq > /dev/null\n",
    "!wget -q http://apache.osuosl.org/spark/spark-3.3.3/spark-3.3.3-bin-hadoop3.tgz\n",
    "!tar xf spark-3.3.3-bin-hadoop3.tgz\n",
    "!pip install -q findspark\n",
    "\n",
    "import os\n",
    "os.environ[\"JAVA_HOME\"] = \"/usr/lib/jvm/java-8-openjdk-amd64\"\n",
    "os.environ[\"SPARK_HOME\"] = \"/content/spark-3.3.3-bin-hadoop3\"\n",
    "\n",
    "import findspark\n",
    "findspark.init() \n",
    "from pyspark import SparkContext\n",
    "sc = SparkContext.getOrCreate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7fc5XBKBhHjX"
   },
   "outputs": [],
   "source": [
    "wordsList = ['cat', 'elephant', 'rat', 'rat', 'cat']\n",
    "wordsRDD = sc.parallelize(wordsList, 4)\n",
    "# Print out the type of wordsRDD\n",
    "print(type(wordsRDD))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "TArxKoGehHjc"
   },
   "source": [
    "#### ** (1b) Pluralize and test **\n",
    "\n",
    "Let's use a `map()` transformation to add the letter 's' to each string in the base RDD we just created. We'll define a Python function that returns the word with an 's' at the end of the word.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "R8_TBGGUhHjc"
   },
   "outputs": [],
   "source": [
    "def makePlural(word):\n",
    "    \"\"\"Adds an 's' to `word`.\n",
    "\n",
    "    Note:\n",
    "        This is a simple function that only adds an 's'.  No attempt is made to follow proper\n",
    "        pluralization rules.\n",
    "\n",
    "    Args:\n",
    "        word (str): A string.\n",
    "\n",
    "    Returns:\n",
    "        str: A string with 's' added to it.\n",
    "    \"\"\"\n",
    "    return word + 's'\n",
    "\n",
    "print(makePlural('cat'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kmVPR4GdhHjf"
   },
   "outputs": [],
   "source": [
    "# One way of completing the function\n",
    "def makePlural(word):\n",
    "    return word + 's'\n",
    "\n",
    "print(makePlural('cat'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k_fiL6mLX-yj"
   },
   "source": [
    "You ALSO can use some third-party packages to test your code. However, the Google colab platform is not supporting this package. You can try the below codes in your Anacoda Jupyter notebook or your local python environment.\n",
    "\n",
    "```\n",
    "# Load in the testing code and check to see if your answer is correct\n",
    "# If incorrect it will report back '1 test failed' for each failed test\n",
    "# Make sure to rerun any cell you change before trying the test again\n",
    "\n",
    "!pip install test_helper\n",
    "from test_helper import Test\n",
    "# TEST Pluralize and test (1b)\n",
    "Test.assertEquals(makePlural('rat'), 'rats', 'incorrect result: makePlural does not add an s')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z5C-yEt4hHjl"
   },
   "source": [
    "#### ** (1c) Apply `makePlural` to the base RDD **\n",
    "\n",
    "Now pass each item in the base RDD into a [map()](http://spark.apache.org/docs/latest/api/python/pyspark.html#pyspark.RDD.map) transformation that applies the `makePlural()` function to each element. And then call the [collect()](http://spark.apache.org/docs/latest/api/python/pyspark.html#pyspark.RDD.collect) action to see the transformed RDD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "qWNIzYDChHjm"
   },
   "outputs": [],
   "source": [
    "pluralRDD = wordsRDD.map(makePlural)\n",
    "print(pluralRDD.collect())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HO56HJlEY9Iv"
   },
   "source": [
    "You can try the below testing code in the Anaconda Jupyter notebook or the local python enviroment to verify the pluralRDD.collect() method\n",
    "```\n",
    "#TEST Apply makePlural to the base RDD(1c)\n",
    "Test.assertEquals(pluralRDD.collect(), ['cats', 'elephants', 'rats', 'rats', 'cats'],\n",
    "                  'incorrect values for pluralRDD')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rxSzTCVQhHjr"
   },
   "source": [
    "#### ** (1d) Pass a `lambda` function to `map` **\n",
    "\n",
    "Let's create the same RDD using a `lambda` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zaSaE3WPhHjr"
   },
   "outputs": [],
   "source": [
    "pluralLambdaRDD = wordsRDD.map(lambda word: word + 's')\n",
    "print(pluralLambdaRDD.collect())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "K0zDeFEvZhQv"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Pass a lambda function to map (1d)\n",
    "Test.assertEquals(pluralLambdaRDD.collect(), ['cats', 'elephants', 'rats', 'rats', 'cats'],\n",
    "                  'incorrect values for pluralLambdaRDD (1d)')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "iyu3TaOqhHjv"
   },
   "source": [
    "#### ** (1e) Length of each word **\n",
    "\n",
    "Now use `map()` and a `lambda` function to return the number of characters in each word.  We'll `collect` this result directly into a variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "GRKtzmF5hHjw"
   },
   "outputs": [],
   "source": [
    "pluralLengths = (pluralRDD.map(lambda word: len(word)).collect())\n",
    "print(pluralLengths)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QHZTDv8baLdW"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Length of each word (1e)\n",
    "Test.assertEquals(pluralLengths, [4, 9, 4, 4, 4],\n",
    "                  'incorrect values for pluralLengths')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Y0Or5sSmhHj1"
   },
   "source": [
    "#### ** (1f) Pair RDDs **\n",
    "\n",
    "The next step in writing our word counting program is to create a new type of RDD, called a pair RDD. A pair RDD is an RDD where each element is a pair tuple `(k, v)` where `k` is the key and `v` is the value. In this example, we will create a pair consisting of `('<word>', 1)` for each word element in the RDD.\n",
    "\n",
    "We can create the pair RDD using the `map()` transformation with a `lambda()` function to create a new RDD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ta0eZRLqhHj1"
   },
   "outputs": [],
   "source": [
    "wordPairs = wordsRDD.map(lambda word: (word, 1))\n",
    "print(wordPairs.collect())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "nAWahl1yhHj6"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Pair RDDs (1f)\n",
    "Test.assertEquals(wordPairs.collect(),\n",
    "                  [('cat', 1), ('elephant', 1), ('rat', 1), ('rat', 1), ('cat', 1)],\n",
    "                  'incorrect value for wordPairs')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QBTS_VIvhHj6"
   },
   "source": [
    "## 2. Counting with pair RDDs "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ObgED2PChHj8"
   },
   "source": [
    "\n",
    "Now, let's count the number of times a particular word appears in the RDD. There are multiple ways to perform the counting, but some are much less efficient than others.\n",
    "\n",
    "A naive approach would be to `collect()` all of the elements and count them in the driver program. While this approach could work for small datasets, we want an approach that will work for any size dataset including terabyte- or petabyte-sized datasets. In addition, performing all of the work in the driver program is slower than performing it in parallel in the workers. For these reasons, we will use data parallel operations."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hzHeKl6yhHkC"
   },
   "source": [
    "#### ** (2a) `groupByKey()` approach **\n",
    "\n",
    "An approach you might first consider (we'll see shortly that there are better ways) is based on using the [groupByKey()](http://spark.apache.org/docs/latest/api/python/pyspark.html#pyspark.RDD.groupByKey) transformation. As the name implies, the `groupByKey()` transformation groups all the elements of the RDD with the same key into a single list in one of the partitions. There are two problems with using `groupByKey()`:\n",
    "  +   The operation requires a lot of data movement to move all the values into the appropriate partitions.\n",
    "  +   The lists can be very large. Consider a word count of English Wikipedia: the lists for common words (e.g., the, a, etc.) would be huge and could exhaust the available memory in a worker.\n",
    " \n",
    "Use `groupByKey()` to generate a pair RDD of type `('word', iterator)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "VafOB4GbhHkF"
   },
   "outputs": [],
   "source": [
    "# Note that groupByKey requires no parameters\n",
    "wordsGrouped = wordPairs.groupByKey()\n",
    "for key, value in wordsGrouped.collect():\n",
    "    print('{0}: {1}'.format(key, list(value)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "4HHjDo7sbBNx"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python environment to verify your code.\n",
    "```\n",
    "# TEST groupByKey() approach (2a)\n",
    "Test.assertEquals(sorted(wordsGrouped.mapValues(lambda x: list(x)).collect()),\n",
    "                  [('cat', [1, 1]), ('elephant', [1]), ('rat', [1, 1])],\n",
    "                  'incorrect value for wordsGrouped')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "s4B23UmNhHkR"
   },
   "source": [
    "#### ** (2b) Use `groupByKey()` to obtain the counts **\n",
    "\n",
    "Using the `groupByKey()` transformation creates an RDD containing 3 elements, each of which is a pair of a word and a Python iterator.\n",
    "\n",
    "Now sum the iterator using a `map()` transformation.  The result should be a pair RDD consisting of (word, count) pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "7II0HhHvhHkS"
   },
   "outputs": [],
   "source": [
    "wordCountsGrouped = wordsGrouped.map(lambda x: (x[0], sum(x[1])))\n",
    "print(wordCountsGrouped.collect())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fBxzigRtbuZL"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Use groupByKey() to obtain the counts (2b)\n",
    "Test.assertEquals(sorted(wordCountsGrouped.collect()),\n",
    "                  [('cat', 2), ('elephant', 1), ('rat', 2)],\n",
    "                  'incorrect value for wordCountsGrouped')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Nr4Haag1hHkb"
   },
   "source": [
    "#### ** (2c) Counting using `reduceByKey` **\n",
    "\n",
    "A better approach is to start from the pair RDD and then use the [reduceByKey()](http://spark.apache.org/docs/latest/api/python/pyspark.html#pyspark.RDD.reduceByKey) transformation to create a new pair RDD. The `reduceByKey()` transformation gathers together pairs that have the same key and applies the function provided to two values at a time, iteratively reducing all of the values to a single value. `reduceByKey()` operates by applying the function first within each partition on a per-key basis and then across the partitions, allowing it to scale efficiently to large datasets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "G68HDkVNhHkc"
   },
   "outputs": [],
   "source": [
    "# Note that reduceByKey takes in a function that accepts two values and returns a single value\n",
    "wordCounts = wordPairs.reduceByKey(lambda a, b: a + b)\n",
    "print(wordCounts.collect())    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "WsDsL3KWb90U"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Counting using reduceByKey (2c)\n",
    "Test.assertEquals(sorted(wordCounts.collect()), [('cat', 2), ('elephant', 1), ('rat', 2)],\n",
    "                  'incorrect value for wordCounts')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "7TOgoL_QhHkj"
   },
   "source": [
    "#### ** (2d) All together **\n",
    "\n",
    "The expert version of the code performs the `map()` to pair RDD, `reduceByKey()` transformation, and `collect` in one statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Cb95s_LLhHkk"
   },
   "outputs": [],
   "source": [
    "wordCountsCollected = (wordsRDD\n",
    "                       .map(lambda w: (w, 1))\n",
    "                       .reduceByKey(lambda a, b: a + b)\n",
    "                       .collect())\n",
    "print(wordCountsCollected) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aUTjgBp_hHkn"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST All together (2d)\n",
    "Test.assertEquals(sorted(wordCountsCollected), [('cat', 2), ('elephant', 1), ('rat', 2)],\n",
    "                  'incorrect value for wordCountsCollected')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "bpuMlLCxhHko"
   },
   "source": [
    "## 3. Finding unique words and a mean value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "1jks8S2rhHkp"
   },
   "source": [
    "#### ** (3a) Unique words **\n",
    "\n",
    "Calculate the number of unique words in `wordsRDD`.  You can use other RDDs that you have already created to make this easier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "mZOsnXtZhHkp"
   },
   "outputs": [],
   "source": [
    "uniqueWords = len(wordCountsCollected)\n",
    "print(uniqueWords)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_G0F4kP3cgrd"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Unique words (3a)\n",
    "Test.assertEquals(uniqueWords, 3, 'incorrect count of uniqueWords')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qcsJerAZhHkt"
   },
   "source": [
    "#### ** (3b) Mean using `reduce` **\n",
    "\n",
    "Find the mean number of words per unique word in `wordCounts`.\n",
    "\n",
    "Use a `reduce()` action to sum the counts in `wordCounts` and then divide by the number of unique words.  First `map()` the pair RDD `wordCounts`, which consists of (key, value) pairs, to an RDD of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "cLkFzlKxhHkt"
   },
   "outputs": [],
   "source": [
    "from operator import add\n",
    "totalCount =  (wordCounts\n",
    "              .map(lambda x: x[1])\n",
    "              .reduce(add))\n",
    "average = totalCount / float(uniqueWords)\n",
    "print(totalCount)\n",
    "print(round(average, 2)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "f_sVY9GlhHkw"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Mean using reduce (3b)\n",
    "Test.assertEquals(round(average, 2), 1.67, 'incorrect value of average')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "m_9SqjkOhHkw"
   },
   "source": [
    "## 4. Apply word count to a file "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "dC2UaCHBhHkx"
   },
   "source": [
    "\n",
    "In this section we will finish developing our word count application.  We'll have to build the `wordCount` function, deal with real world problems like capitalization and punctuation, load in our data source, and compute the word count on the new data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Qs6eXHBqhHkx"
   },
   "source": [
    "#### ** (4a) `wordCount` function **\n",
    "\n",
    "First, define a function for word counting.  You should reuse the techniques that have been covered in earlier parts of this lab.  This function should take in a RDD that is a list of words like `wordsRDD` and return a pair RDD that has all of the words and their associated counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zCl363hehHky"
   },
   "outputs": [],
   "source": [
    "# TODO: Replace <FILL IN> with appropriate code\n",
    "def wordCount(wordListRDD):\n",
    "    \"\"\"Creates a pair RDD with word counts from an RDD of words.\n",
    "\n",
    "    Args:\n",
    "        wordListRDD (RDD of str): An RDD consisting of words.\n",
    "\n",
    "    Returns:\n",
    "        RDD of (str, int): An RDD consisting of (word, count) tuples.\n",
    "    \"\"\"\n",
    "    wordsRDD = (wordListRDD\n",
    "                       .map(lambda w: (w, 1))\n",
    "                       .reduceByKey(lambda a, b: a + b))\n",
    "    return wordsRDD\n",
    "\n",
    "print(wordCount(wordsRDD).collect())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "HGvAiRA3dV6B"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST wordCount function (4a)\n",
    "Test.assertEquals(sorted(wordCount(wordsRDD).collect()),\n",
    "                  [('cat', 2), ('elephant', 1), ('rat', 2)],\n",
    "                  'incorrect definition for wordCount function')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "atD4UJ9RhHk4"
   },
   "source": [
    "#### ** (4b) Capitalization and punctuation **\n",
    "\n",
    "Real world files are more complicated than the data we have been using in this lab. Some of the issues we have to address are:\n",
    "  +   Words should be counted independent of their capitialization (e.g., Spark and spark should be counted as the same word).\n",
    "  +   All punctuation should be removed.\n",
    "  +   Any leading or trailing spaces on a line should be removed.\n",
    " \n",
    "Define the function `removePunctuation` that converts all text to lower case, removes any punctuation, and removes leading and trailing spaces.  Use the Python [re](https://docs.python.org/2/library/re.html) module to remove any text that is not a letter, number, or space. Reading `help(re.sub)` might be useful."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "zDJ2G73khHk4"
   },
   "outputs": [],
   "source": [
    "import re\n",
    "def removePunctuation(text):\n",
    "    \"\"\"Removes punctuation, changes to lower case, and strips leading and trailing spaces.\n",
    "\n",
    "    Note:\n",
    "        Only spaces, letters, and numbers should be retained.  Other characters should should be\n",
    "        eliminated (e.g. it's becomes its).  Leading and trailing spaces should be removed after\n",
    "        punctuation is removed.\n",
    "\n",
    "    Args:\n",
    "        text (str): A string.\n",
    "\n",
    "    Returns:\n",
    "        str: The cleaned up string.\n",
    "    \"\"\"\n",
    "    return ''.join([c.lower() for c in text if c.isalnum() or c == ' ']).strip()\n",
    "print(removePunctuation('Hi, you!'))\n",
    "print(removePunctuation(' No under_score!'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QOhlNgE3d20Z"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Capitalization and punctuation (4b)\n",
    "Test.assertEquals(removePunctuation(\" The Elephant's 4 cats. \"),\n",
    "                  'the elephants 4 cats',\n",
    "                  'incorrect definition for removePunctuation function')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UP7qiHuUhHk8"
   },
   "source": [
    "#### ** (4c) Load a text file **\n",
    "\n",
    "For the next part of this lab, we will use the [Complete Works of William Shakespeare](http://www.gutenberg.org/ebooks/100) from [Project Gutenberg](http://www.gutenberg.org/wiki/Main_Page). To convert a text file into an RDD, we use the `SparkContext.textFile()` method. We also apply the recently defined `removePunctuation()` function using a `map()` transformation to strip out the punctuation and change all text to lowercase.  Since the file is large we use `take(15)`, so that we only print 15 lines.\n",
    "\n",
    "Assume that the file shakespeare.txt has been uploaded to DBFS file store, and you note down the address."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "tfwcuZaChHk8"
   },
   "outputs": [],
   "source": [
    "!pip install wget\n",
    "import wget\n",
    "\n",
    "link_to_data = 'https://github.com/tulip-lab/sit742/raw/master/Jupyter/data/shakespeare.txt'\n",
    "DataSet = wget.download(link_to_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "0A6c-cOBkThD"
   },
   "outputs": [],
   "source": [
    "#Copy the above removePunctuation function\n",
    "def removePunctuation(text):\n",
    "    \"\"\"Removes punctuation, changes to lower case, and strips leading and trailing spaces.\n",
    "\n",
    "    Note:\n",
    "        Only spaces, letters, and numbers should be retained.  Other characters should should be\n",
    "        eliminated (e.g. it's becomes its).  Leading and trailing spaces should be removed after\n",
    "        punctuation is removed.\n",
    "\n",
    "    Args:\n",
    "        text (str): A string.\n",
    "\n",
    "    Returns:\n",
    "        str: The cleaned up string.\n",
    "    \"\"\"\n",
    "    return ''.join([c.lower() for c in text if c.isalnum() or c == ' ']).strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "kWVNZQFmhHk-"
   },
   "outputs": [],
   "source": [
    "fileName = 'shakespeare.txt'\n",
    "\n",
    "shakespeareRDD = (sc\n",
    "                  .textFile(fileName, 8)\n",
    "                  .map(removePunctuation))\n",
    "\n",
    "#To print the first 10 elements in the shakespeareRDD\n",
    "print(shakespeareRDD.zipWithIndex().collect()[0:10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "wkqZi6fbhHlA"
   },
   "source": [
    "#### ** (4d) Words from lines **\n",
    "\n",
    "Before we can use the `wordcount()` function, we have to address two issues with the format of the RDD:\n",
    "  +   The first issue is that  that we need to split each line by its spaces.\n",
    "  +   The second issue is we need to filter out empty lines.\n",
    " \n",
    "Apply a transformation that will split each element of the RDD by its spaces. For each element of the RDD, you should apply Python's string [split()](https://docs.python.org/2/library/string.html#string.split) function. You might think that a `map()` transformation is the way to do this, but think about what the result of the `split()` function will be."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "1OsbK-AVhHlB"
   },
   "outputs": [],
   "source": [
    "shakespeareWordsRDD = shakespeareRDD.flatMap(lambda x: x.split(' '))\n",
    "shakespeareWordCount = shakespeareWordsRDD.count()\n",
    "print(shakespeareWordsRDD.top(5))\n",
    "print(shakespeareWordCount) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "R5LAacF1lQV5"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Words from lines (4d)\n",
    "# This test allows for leading spaces to be removed either before or after\n",
    "# punctuation is removed.\n",
    "Test.assertTrue(shakespeareWordCount == 927631 or shakespeareWordCount == 928908,\n",
    "                'incorrect value for shakespeareWordCount')\n",
    "Test.assertEquals(shakespeareWordsRDD.top(5),\n",
    "                  [u'zwaggerd', u'zounds', u'zounds', u'zounds', u'zounds'],\n",
    "                  'incorrect value for shakespeareWordsRDD')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "AJEgyM9YhHlE"
   },
   "source": [
    "#### ** (4e) Remove empty elements **\n",
    "The next step is to filter out the empty elements.  Remove all entries where the word is `''`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "DKujj4eIhHlE"
   },
   "outputs": [],
   "source": [
    "# TODO: Replace <FILL IN> with appropriate code\n",
    "shakeWordsRDD = shakespeareWordsRDD.filter(lambda x: x != '')\n",
    "shakeWordCount = shakeWordsRDD.count()\n",
    "print (shakeWordCount)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "k1S01VPZlgXJ"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Remove empty elements (4e)\n",
    "Test.assertEquals(shakeWordCount, 882996, 'incorrect value for shakeWordCount')\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Tmqjhx9whHlM"
   },
   "source": [
    "#### ** (4f) Count the words **\n",
    "\n",
    "We now have an RDD that is only words.  Next, let's apply the `wordCount()` function to produce a list of word counts. We can view the top 15 words by using the `takeOrdered()` action; however, since the elements of the RDD are pairs, we need a custom sort function that sorts using the value part of the pair.\n",
    "\n",
    "You'll notice that many of the words are common English words. These are called stopwords. In a later lab, we will see how to eliminate them from the results.\n",
    "\n",
    "Use the `wordCount()` function and `takeOrdered()` to obtain the fifteen most common words and their counts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "_8YJVnx8hHlM"
   },
   "outputs": [],
   "source": [
    "top15WordsAndCounts = wordCount(shakeWordsRDD).takeOrdered(15, lambda k: -k[1])\n",
    "print(top15WordsAndCounts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rozFSEifluEg"
   },
   "source": [
    "You can try the below codes in the Anaconda Jupyter notebook or the local python enviroment to verify your code.\n",
    "```\n",
    "# TEST Count the words (4f)\n",
    "Test.assertEquals(top15WordsAndCounts,\n",
    "                  [(u'the', 27361), (u'and', 26028), (u'i', 20681), (u'to', 19150), (u'of', 17463),\n",
    "                   (u'a', 14593), (u'you', 13615), (u'my', 12481), (u'in', 10956), (u'that', 10890),\n",
    "                   (u'is', 9134), (u'not', 8497), (u'with', 7771), (u'me', 7769), (u'it', 7678)],\n",
    "                  'incorrect value for top15WordsAndCounts')\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "M04H-CS-WordCount.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}