BigData_text_Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part A: Analysing text data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this assignment we are going to analysy two books which are based on software development methodologies. The two files/books which we are going to use for this part of the assignment is:\n",
    "* Book1: \"Agile Processes in Software Engineering and Extreme Programming.txt\"\n",
    "* Book2: \"Scrum Handbook.txt\" "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our task will be to see the distribution of words, the most common words in both books and the average frequency. This approach can also be scaled to find the most common words and distribution of all words in the Internet."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step1: Importing pyspark and initialising it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this step we will be importing a library called pyspark. Pyspark is a python API for spark. In this we are going to use \"SparkContext\" which is a main entry for Spark functionality. We are also going to use \"SparkConf\" which is used for configuring Spark. Now our first step would be to import SparkContext and SparkConf libraries from pyspark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install pyspark\n",
    "from pyspark import SparkContext, SparkConf \n",
    "from pyspark.sql import SparkSession\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have imported the required libraries we now use this to create a Spark Session and configure Spark to be used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Construct a configuration\n",
    "conf = SparkConf()\n",
    "conf.set(\"spark.app.name\", \"Advanced Spark Programming\")\n",
    "conf.set(\"spark.master\", \"local[2]\")\n",
    "conf.set(\"spark.ui.port\", \"4050\") # Override the default port 4040\n",
    "\n",
    "\n",
    "sc = SparkContext(conf=conf)\n",
    "spark = SparkSession(sparkContext=sc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# We add this line to avoid an error : \"Cannot run multiple SparkContexts at once\". \n",
    "# If there is an existing spark context, we will reuse it instead of creating a new context.\n",
    "sc = SparkContext.getOrCreate()\n",
    "\n",
    "# local[*]: run Spark locally with as many working processors as logical cores on your machine.\n",
    "# In the field of `master`, we use a local server with as many working processors (or threads) as possible (i.e. `local[*]`). \n",
    "# If we want Spark to run locally with 'k' worker threads, we can specify as `local[k]`.\n",
    "# The `appName` field is a name to be shown on the Sparking cluster UI. \n",
    "\n",
    "# If there is no existing spark context, we now create a new context\n",
    "if (sc is None):\n",
    "    sc = SparkContext(master=\"local[*]\", appName=\"Assignment1\")\n",
    "\n",
    "spark = SparkSession(sparkContext=sc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step2: Creating Resilient Distributed Datasets (RDDs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The main abstraction which Spark provides is a resilient distributed dataset also known as RDD. A RDD is a collection of elements which is partitioned across the nodes of the cluster that can be operated on in parallel. Now in this step we are going to create RDD's for the files which is given to us in the assignment specification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reading all the files which is given in the assignment\n",
    "agile_process = sc.textFile('Agile Processes  in Software Engineering  and Extreme Programming.txt')\n",
    "scrum_handbook = sc.textFile('Scrum\\ Handbook.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This part of the code is to display the total number of elements in each RDD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of lines in Agile Processes txt file is:  21569\n",
      "Numbe of lines in Scrum Handbook txt file is:  4617\n"
     ]
    }
   ],
   "source": [
    "# count of number of lines for each file which has been read\n",
    "print(\"Number of lines in Agile Processes txt file is: \",agile_process.count())\n",
    "print(\"Numbe of lines in Scrum Handbook txt file is: \",scrum_handbook.count())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step3:  Cleaning and Manipulating the text"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now in this step there is some data wrangline which has to be done on the given datasets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The steps which have to be done here are:\n",
    "1. Removes all characters which are not alphabets except space(s).\n",
    "2. Changes all upper case letters to lowercase.\n",
    "3. Removes all leading or trailing spaces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function which is written below is to take a string in consideration and so all the tasks which are mentioned above. Each element in the RDD is a string and hence we are going to perform the tasks on a string. In the function the 'isalpha' fucntion is being used to remove any non alphabetic characters. The 'lower' function is being used to convert the string to lower case and the strip function is being used to remove all the begining and trailing spaces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to remove all characters which are not alphabets except spaces\n",
    "## using the isalpha function we can find out wether a given character is an alphabet or not\n",
    "# this function is used to remove all the leading and trailing spaces\n",
    "def cleaning(inp):\n",
    "    retstr = \"\"\n",
    "    for i in inp:\n",
    "        if not i.isalpha() and i!=\" \":\n",
    "                i = \"\"        \n",
    "        retstr += i\n",
    "    return retstr.lower().strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have formed the function we now use this function to perform the wrangling/cleaning tasks on the RDD. The function can be used to perform a given task on the RDD using the map function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mapping the above function to the RDD\n",
    "agile_processcess_clean = agile_process.map(cleaning)\n",
    "scrum_handbook_clean = scrum_handbook.map(cleaning)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now have the cleaned RDD with us!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step4: Transforming data and counting the words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this step we are going to split the RDD based on spaces and then find the frequency of all words. Each element in the list would be the tuple and each tuple would consist of the word and the number of occurences of the word. We do this for both the datasets Agile and Scrum."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case1: Agile Process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we obtain the word frequency of the Agile dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code is to split all the words and then find the occurences of each of the words\n",
    "\n",
    "tokenized_agile = agile_processcess_clean.flatMap(lambda line: line.split(\" \"))\\\n",
    ".filter(lambda words: words != '')\n",
    "\n",
    "# Extract the first word of each line (the log level) and do a count\n",
    "word_frequency_agile = tokenized_agile.map(lambda words: (words,1))\\\n",
    ".reduceByKey(lambda x,y: x+y) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have found the word frequency of the Agile dataset we now sort the tuples based on the word frequency count and display only the top 20 occurences of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Top 20 most frequent words in Book1 or Agile is: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(8145, 'the'),\n",
       " (3965, 'and'),\n",
       " (3944, 'of'),\n",
       " (3714, 'to'),\n",
       " (3076, 'in'),\n",
       " (2701, 'a'),\n",
       " (1539, 'is'),\n",
       " (1355, 'that'),\n",
       " (1194, 'for'),\n",
       " (1028, 'as'),\n",
       " (1015, 'on'),\n",
       " (975, 'we'),\n",
       " (969, 'with'),\n",
       " (922, 'software'),\n",
       " (915, 'this'),\n",
       " (784, 'are'),\n",
       " (748, 'agile'),\n",
       " (741, 'it'),\n",
       " (737, 'development'),\n",
       " (711, 'was')]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this code is to display the top 20 occurences of the words\n",
    "\n",
    "word_frequency_swap_agile = word_frequency_agile.map(lambda x: (x[1],x[0]))\n",
    "top20_agile = word_frequency_swap_agile.sortByKey(0,1).take(20)\n",
    "print('Top 20 most frequent words in Book1 or Agile is: ')\n",
    "top20_agile"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case2: Scrum Handbook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we obtain the word frequency of the Scrum dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code is to split all the words and then find the occurences of each of the words\n",
    "\n",
    "tokenized_scrum = scrum_handbook_clean.flatMap(lambda line: line.split(\" \"))\\\n",
    ".filter(lambda words: words != '')\n",
    "\n",
    "# Extract the first word of each line (the log level) and do a count\n",
    "word_frequency_scrum = tokenized_scrum.map(lambda words: (words,1))\\\n",
    ".reduceByKey(lambda x,y: x+y) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have found the word frequency of the Scrum dataset we now sort the tuples based on the word frequency count and display only the top 20 occurences of words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The 20 most occuring words in scrum or Book2 is: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(1238, 'the'),\n",
       " (537, 'of'),\n",
       " (534, 'and'),\n",
       " (477, 'to'),\n",
       " (451, 'a'),\n",
       " (395, 'scrum'),\n",
       " (360, 'in'),\n",
       " (348, 'is'),\n",
       " (260, 'team'),\n",
       " (232, 'product'),\n",
       " (195, 'for'),\n",
       " (181, 'that'),\n",
       " (165, 'it'),\n",
       " (149, 'on'),\n",
       " (146, 'sprint'),\n",
       " (142, 'this'),\n",
       " (132, 'with'),\n",
       " (124, 'as'),\n",
       " (119, 'are'),\n",
       " (118, 'by')]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# this code is to display the top 20 occurences of the words\n",
    "\n",
    "word_frequency_swap_scrum = word_frequency_scrum.map(lambda x: (x[1],x[0]))\n",
    "top20_scrum = word_frequency_swap_scrum.sortByKey(0,1).take(20)\n",
    "print('The 20 most occuring words in scrum or Book2 is: ')\n",
    "top20_scrum"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Removing all the stop words"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Stop words can be defined as words which are filtered out before processing of natural language data.Stop words are the words which commonly occur in the text. Usually while doing anaysis we would not want one specific set of words taking up space in the datset. Thus one of the task which we do before analysing datasets is removing stopwords."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In python stopwords can be handeled using a library calles NLTK(Natural Language Toolkit). Our first task in this step now would be to import the NLTK library. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[nltk_data] Downloading package stopwords to\n",
      "[nltk_data]     /Users/sohailsankanur/nltk_data...\n",
      "[nltk_data]   Package stopwords is already up-to-date!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import nltk\n",
    "nltk.download('stopwords')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have downloaded all the common english stopwords we would now use this for removing stopwords from the dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.corpus import stopwords\n",
    "stop_words=set(stopwords.words('english'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create a python function names 'stop_removal' to remove all the stopwords from each input string which is supplied to the function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to remove all the stop words in the RDD\n",
    "def stop_removal(inp):\n",
    "    inplis = inp.split()\n",
    "    finstr = ''\n",
    "    for i in inplis:\n",
    "        if i not in stop_words:\n",
    "            finstr = finstr + i + \" \"\n",
    "    return finstr.strip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case1: Agile Process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the 'stop_removal' function to remove all the stopwords from the Agile dataset. We can use the map function of pyspark for using a python function to perform an operation on the pyspark RDD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "agile_no_stop = agile_processcess_clean.map(stop_removal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we find the number of unique words and the number of total words in the Agile RDD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code will help us find the total number of words and the number of unique words in the RDD\n",
    "\n",
    "agile_tokenized = agile_no_stop.flatMap(lambda line: line.split(\" \"))\\\n",
    ".filter(lambda words: words != '')\n",
    "\n",
    "agile_unique_count = agile_tokenized.map(lambda words: (words,1))\\\n",
    ".reduceByKey(lambda x,y: x+y).count()                                    # this gives us the number of unique\n",
    "                                                                         # words in the RDD\n",
    "\n",
    "agile_total_count = agile_tokenized.map(lambda x: len(x)).sum()          # this gives us the total number of \n",
    "                                                                         # words in RDD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of unique words we have in agile RDD is:  9611\n"
     ]
    }
   ],
   "source": [
    "print('The number of unique words we have in agile RDD is: ', agile_unique_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case2: Scrum Handbook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the 'stop_removal' function to remove all the stopwords from the Scrum dataset. We can use the map function of pyspark for using a python function to perform an operation on the pyspark RDD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "scrum_no_stop = scrum_handbook_clean.map(stop_removal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we find the number of unique words and the number of total words in the Scrum RDD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code will help us find the total number of words and the number of unique words in the RDD\n",
    "\n",
    "scrum_tokenized = scrum_no_stop.flatMap(lambda line: line.split(\" \"))\\\n",
    ".filter(lambda words: words != '')\n",
    "\n",
    "scrum_unique_count = scrum_tokenized.map(lambda words: (words,1))\\\n",
    ".reduceByKey(lambda x,y: x+y).count()                                    # this gives us the number of unique\n",
    "                                                                         # words in the RDD\n",
    "\n",
    "scrum_total_count = scrum_tokenized.map(lambda x: len(x)).sum()          # this gives us the total number of \n",
    "                                                                         # words in RDD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of unique words we have in scrum RDD is:  2936\n"
     ]
    }
   ],
   "source": [
    "print('The number of unique words we have in scrum RDD is: ',scrum_unique_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step6: Finding the average occurence of a word:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this step we find out the average occurence of a word. This can be found by dividing the total number of words by number of unique words."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case1: Agile Process"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We find the average occurence for the Agile dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to find the average occurence of the words we have to divide the total number of words by the number of unique words\n",
    "agile_average_count = agile_total_count / agile_unique_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average occurence of words in agile is:  57.30922900842784\n"
     ]
    }
   ],
   "source": [
    "print(\"Average occurence of words in agile is: \", agile_average_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Case2: Scrum Handbook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We find the average occurence for the Scrum dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# to find the average occurence of the words we have to divide the total number of words by the number of unique words\n",
    "scrum_average_count = scrum_total_count / scrum_unique_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average occurence of words in scrum is:  24.86376021798365\n"
     ]
    }
   ],
   "source": [
    "print(\"Average occurence of words in scrum is: \", scrum_average_count)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step7: Exploratory data analysis:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this step our task would be to use the standard visualisation python library ***matplotlib*** and analyse the distribution of words in the dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task1: Getting the Data for Book1 or Agile:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we find the word frequency for Book 1 or Agile file for using it to plot a word distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code is to split all the words and then find the occurences of each of the words\n",
    "\n",
    "tokenized_agile_no_stop = agile_no_stop.flatMap(lambda line: line.split(\" \"))\\\n",
    ".filter(lambda words: words != '')\n",
    "\n",
    "# Extract the first word of each line (the log level) and do a count\n",
    "word_frequency_agile_no_stop = tokenized_agile_no_stop.map(lambda words: (words,1))\\\n",
    ".reduceByKey(lambda x,y: x+y) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_frequency_swap_agile_no_stop = word_frequency_agile_no_stop.map(lambda x: (x[1],x[0]))\n",
    "word_sorted_agile_no_stop = word_frequency_swap_agile_no_stop.sortByKey(0,1)\n",
    "word_list_agile_no_stop = word_sorted_agile_no_stop.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "x_agile = []\n",
    "y_agile = []\n",
    "for i in word_list_agile_no_stop:\n",
    "    x_agile.append(i[0])\n",
    "    y_agile.append(i[1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task2: Getting the Data for Book2 or Scrum:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we find the word frequency for Book 2 or Scrum file for using it to plot a word distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code is to split all the words and then find the occurences of each of the words\n",
    "\n",
    "tokenized_scrum = scrum_no_stop.flatMap(lambda line: line.split(\" \"))\\\n",
    ".filter(lambda words: words != '' )\n",
    "\n",
    "# Extract the first word of each line (the log level) and do a count\n",
    "word_frequency_scrum = tokenized_scrum.map(lambda words: (words,1))\\\n",
    ".reduceByKey(lambda x,y: x+y) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_frequency_swap_scrum = word_frequency_scrum.map(lambda x: (x[1],x[0]))\n",
    "word_sorted_scrum = word_frequency_swap_scrum.sortByKey(0,1)\n",
    "word_list_scrum_no_stop = word_sorted_scrum.collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "x_scrum = []\n",
    "y_scrum = []\n",
    "for i in word_list_scrum_no_stop:\n",
    "    x_scrum.append(i[0])\n",
    "    y_scrum.append(i[1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now the word distribution plot for both the Books is as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As given in the assignment specification we are comparing the distribution of words in Book1 and Book2. As specified in the assignment specification a log scale has to be used to plot the graph. Thus in this assignment a semilog graph is being used for this task."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x1a237749b0>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10,10))\n",
    "plt.title(\"Exploratory Data Analysis of Word Distribution\")\n",
    "plt.semilogy(sorted(x_scrum, reverse= True))\n",
    "plt.semilogy(sorted(x_agile, reverse=True))\n",
    "plt.gca().legend(('BOOK1 - Scrum','BOOK2 - Agile'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***Inferences from the above plot***\n",
    "\n",
    "In a semilog graph one axis will have logarithmic scale and the other axis will have a linear scale. As we can see from the plot we can see that both the books have a very similar plot hence they have a very similar distribution of words."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparision of 15 most common words which are occuring in both the files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now in this part of the code we do a bar plot for the 15 most common occuring words and we do it side by side so that it would be easy to compare the plots for Agile and Scrum datasets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use a standard consept of matplotlib called subplot. Using the subplot we can align and arrange multiple plots in a single plot which would make it easier for comparision."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<BarContainer object of 15 artists>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x720 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(15,10))\n",
    "\n",
    "plt.subplot(1,3,1)\n",
    "plt.title(\"Exploratory Data Analysis for Agile file- BOOK1\")\n",
    "plt.xlabel(\"Log of occurences of the word\")\n",
    "plt.ylabel(\"Words\")\n",
    "plt.barh(y_agile[:15],x_agile[:15],0.7, color = 'red')\n",
    "\n",
    "\n",
    "\n",
    "plt.subplot(1,3,3)\n",
    "plt.title(\"Exploratory Data Analysis for Scrum file- BOOK2\")\n",
    "plt.xlabel(\"Log of occurences of the word\")\n",
    "plt.ylabel(\"Words\")\n",
    "plt.barh(y_scrum[:15],x_scrum[:15],0.7)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above plot is comparision of 15 most common words in the 2 books. From this plot we can see that the occurences of words in the Book1 is much higher than the occurences of words in Book2. Take for example the top most occuring work in Book1 is software which occurs around 900 times and the top most occuring word in Book2 is scrum which occurs around 400 times.\n",
    "\n",
    "The 3 top most occuring words in Book1 is:\n",
    "* software\n",
    "* agile\n",
    "* development\n",
    "\n",
    "The 3 top most occuring words in Book2 is:\n",
    "* scrum\n",
    "* team\n",
    "* product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References used:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "some codes from Monash University Lecture 2,3,4 has been used for this assignment. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}