From fdc96368a12d1e0f839964508e4ecd3f43ef89c3 Mon Sep 17 00:00:00 2001 From: Suhil Suresh Date: Tue, 29 Nov 2022 00:25:01 +0000 Subject: [PATCH] MiniProject1 --- suhilsuresh.ipynb | 562 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 562 insertions(+) create mode 100644 suhilsuresh.ipynb diff --git a/suhilsuresh.ipynb b/suhilsuresh.ipynb new file mode 100644 index 0000000..f79b8fa --- /dev/null +++ b/suhilsuresh.ipynb @@ -0,0 +1,562 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Written text as operational data\n", + "\n", + "Written text is one type of data\n", + "\n", + "### Why people write?\n", + "\n", + " - To communicate: their thoughts, feelings, urgency, needs, information\n", + "\n", + "### Why people communicate?\n", + "\n", + "1. To express emotions\n", + "1. To share information\n", + "1. To enable or elicit an action\n", + "1. ...\n", + "\n", + "### We will use written text for the purpose other than \n", + "1. To experience emotion\n", + "1. To learn something the author intended us to learn\n", + "1. To do what the author intended us to do\n", + "\n", + "### Instead, we will use written text to recognize who wrote it\n", + " - By calculating and comparing word frequencies in written documents\n", + " \n", + "See, for example, likely fictional story https://medium.com/@amuse/how-the-nsa-caught-satoshi-nakamoto-868affcef595" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example 1. Dictionaries in python (associative arrays)\n", + "\n", + "Plot the frequency distribution of words on a web page." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\t1\n", + "\t1\n", + "403\t1\n", + "Forbidden\t1\n", + "\t1\n", + "

Forbidden

\t1\n", + "

You\t1\n", + "don't\t1\n", + "have\t1\n", + "permission\t1\n", + "to\t1\n" + ] + } + ], + "source": [ + "import requests, re\n", + "# re is a module for regular expressions: to detect various combinations of characters\n", + "import operator\n", + "\n", + "# Start from a simple document\n", + "r = requests .get('http://eecs.utk.edu')\n", + "\n", + "# What comes back includes headers and other HTTP stuff, get just the body of the response\n", + "t = r.text\n", + "\n", + "# obtain words by splitting a string using as separator one or more (+) space/like characters (\\s) \n", + "wds = re.split('\\s+',t)\n", + "\n", + "# now populate a dictionary (wf)\n", + "wf = {}\n", + "for w in wds:\n", + " if w in wf: wf [w] = wf [w] + 1\n", + " else: wf[w] = 1\n", + "\n", + "# dictionaries can not be sorted, so lets get a sorted *list* \n", + "wfs = sorted (wf .items(), key = operator .itemgetter (1), reverse=True) \n", + "\n", + "# lets just have no more than 15 words \n", + "ml = min(len(wfs),15)\n", + "for i in range(1,ml,1):\n", + " print (wfs[i][0]+\"\\t\"+str(wfs[i][1])) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example 2\n", + "\n", + "Lots of markup in the output, lets remove it --- \n", + "\n", + "use BeautifulSoup and nltk modules and practice some regular expressions." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import requests, re, nltk\n", + "from bs4 import BeautifulSoup\n", + "from nltk import clean_html\n", + "from collections import Counter\n", + "import operator\n", + "\n", + "# we may not care about the usage of stop words\n", + "stop_words = nltk.corpus.stopwords.words('english') + [\n", + " 'ut', '\\'re','.', ',', '--', '\\'s', '?', ')', '(', ':', '\\'',\n", + " '\\\"', '-', '}', '{', '&', '|', u'\\u2014' ]\n", + "\n", + "# We most likely would like to remove html markup\n", + "def cleanHtml (html):\n", + " from bs4 import BeautifulSoup\n", + " soup = BeautifulSoup(html, 'html.parser')\n", + " return soup .get_text()\n", + "\n", + "# We also want to remove special characters, quotes, etc. from each word\n", + "def cleanWord (w):\n", + " # r in r'[.,\"\\']' tells to treat \\ as a regular character \n", + " # but we need to escape ' with \\'\n", + " # any character between the brackets [] is to be removed \n", + " wn = re.sub('[,\"\\.\\'&\\|:@>*;/=]', \"\", w)\n", + " # get rid of numbers\n", + " return re.sub('^[0-9\\.]*$', \"\", wn)\n", + " \n", + "# define a function to get text/clean/calculate frequency\n", + "def get_wf (URL):\n", + " # first get the web page\n", + " r = requests .get(URL)\n", + " \n", + " # Now clean\n", + " # remove html markup\n", + " t = cleanHtml (r .text) .lower()\n", + " \n", + " # split string into an array of words using any sequence of spaces \"\\s+\" \n", + " wds = re .split('\\s+',t)\n", + " \n", + " # remove periods, commas, etc stuck to the edges of words\n", + " for i in range(len(wds)):\n", + " wds [i] = cleanWord (wds [i])\n", + " \n", + " # If satisfied with results, lets go to the next step: calculate frequencies\n", + " # We can write a loop to create a dictionary, but \n", + " # there is a special function for everything in python\n", + " # in particular for counting frequencies (like function table() in R)\n", + " wf = Counter (wds)\n", + " \n", + " # Remove stop words from the dictionary wf\n", + " for k in stop_words:\n", + " wf. pop(k, None)\n", + " \n", + " #how many regular words in the document?\n", + " tw = 0\n", + " for w in wf:\n", + " tw += wf[w] \n", + " \n", + " \n", + " # Get ordered list\n", + " wfs = sorted (wf .items(), key = operator.itemgetter(1), reverse=True)\n", + " ml = min(len(wfs),15)\n", + "\n", + " #Reverse the list because barh plots items from the bottom\n", + " return (wfs [ 0:ml ] [::-1], tw)\n", + " \n", + "# Now populate two lists \n", + "(wf_ee, tw_ee) = get_wf('https://www.gutenberg.org/cache/epub/1513/pg1513.txt')\n", + "(wf_bu, tw_bu) = get_wf('https://www.gutenberg.org/files/23042/23042-0.txt')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot the results: are there striking differences in language?\n", + "import numpy as np\n", + "import pylab\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "def plotTwoLists (wf_ee, wf_bu, title):\n", + " f = plt.figure (figsize=(10, 6))\n", + " # this is painfully tedious....\n", + " f .suptitle (title, fontsize=20)\n", + " ax = f.add_subplot(111)\n", + " ax .spines ['top'] .set_color ('none')\n", + " ax .spines ['bottom'] .set_color ('none')\n", + " ax .spines ['left'] .set_color ('none')\n", + " ax .spines ['right'] .set_color ('none')\n", + " ax .tick_params (labelcolor='w', top='off', bottom='off', left='off', right='off', labelsize=20)\n", + "\n", + " # Create two subplots, this is the first one\n", + " ax1 = f .add_subplot (121)\n", + " plt .subplots_adjust (wspace=.5)\n", + "\n", + " pos = np .arange (len(wf_ee)) \n", + " ax1 .tick_params (axis='both', which='major', labelsize=14)\n", + " pylab .yticks (pos, [ x [0] for x in wf_ee ])\n", + " ax1 .barh (range(len(wf_ee)), [ x [1] for x in wf_ee ], align='center')\n", + "\n", + " ax2 = f .add_subplot (122)\n", + " ax2 .tick_params (axis='both', which='major', labelsize=14)\n", + " pos = np .arange (len(wf_bu)) \n", + " pylab .yticks (pos, [ x [0] for x in wf_bu ])\n", + " ax2 .barh (range (len(wf_bu)), [ x [1] for x in wf_bu ], align='center')\n", + "\n", + "plotTwoLists (wf_ee, wf_bu, 'Difference between Romeo and Juliet and The Tempest')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "and\t2836\n", + "of\t2676\n", + "to\t2646\n", + "a\t2217\n", + "in\t1422\n", + "his\t1205\n", + "he\t928\n", + "that\t920\n", + "was\t823\n", + "for\t798\n", + "with\t797\n", + "as\t672\n", + "I\t505\n", + "you\t497\n" + ] + } + ], + "source": [ + "#In case Project gutenberg is blocked you can download text to your laptop and copy to the docker container via scp\n", + "#Assuming the file name you copy is pg4680.txt here is how you change the script\n", + "# Please note the option errors='replace'\n", + "# without it python invariably runs into unicode errors\n", + "f = open ('pg4680.txt', 'r', encoding=\"ascii\", errors='replace')\n", + " \n", + "# What comes back includes headers and other HTTP stuff, get just the body of the response\n", + "t = f.read()\n", + "\n", + "# obtain words by splitting a string using as separator one or more (+) space/like characters (\\s) \n", + "wds = re.split('\\s+',t)\n", + "\n", + "# now populate a dictionary (wf)\n", + "wf = {}\n", + "for w in wds:\n", + " if w in wf: wf [w] = wf [w] + 1\n", + " else: wf [w] = 1\n", + "\n", + "# dictionaries can not be sorted, so lets get a sorted *list* \n", + "wfs = sorted (wf .items(), key = operator .itemgetter (1), reverse=True) \n", + "\n", + "# lets just have no more than 15 words \n", + "ml = min(len(wfs),15)\n", + "for i in range(1,ml,1):\n", + " print (wfs[i][0]+\"\\t\"+str(wfs[i][1])) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Assignment 1\n", + "\n", + "1. Compare word frequencies between two works of a single author.\n", + "1. Compare word frequencies between works of two authors.\n", + "1. Are there some words preferred by one author but used less frequently by another author?\n", + "\n", + "Extra credit\n", + "\n", + "1. The frequency of a specific word, e.g., \"would\" should follow a binomial distribution (each regular word in a document is a trial and with probability p that word is \"would\". The estimate for p is N(\"would\")/N(regular word)). Do these binomial distributions for your chosen word differ significantly between books of the same author or between authors? \n", + "\n", + "Project Gutenberg is a good source of for fiction and non-fiction.\n", + "\n", + "E.g below are two most popular books from Project Gutenberg:\n", + "- Pride and Prejudice at http://www.gutenberg.org/ebooks/1342.txt.utf-8\n", + "- Adventures of Huckleberry Finn at http://www.gutenberg.org/ebooks/76.txt.utf-8" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import requests, re, nltk\n", + "#In case your text is not on Project Gutenberg but at some other URL\n", + "#http://www.fullbooks.com/Our-World-or-The-Slaveholders-Daughter2.html\n", + "# that contains 12 parts\n", + "t = \"\"\n", + "for i in range(2,13):\n", + " r = requests .get('http://www.fullbooks.com/Our-World-or-The-Slaveholders-Daughter' + str(i) + '.html')\n", + " t = t + r.text" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "len(t)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import requests, re, nltk\n", + "from bs4 import BeautifulSoup\n", + "from nltk import clean_html\n", + "from collections import Counter\n", + "import operator\n", + "\n", + "# we may not care about the usage of stop words\n", + "stop_words = nltk.corpus.stopwords.words('english') + [\n", + " 'ut', '\\'re','.', ',', '--', '\\'s', '?', ')', '(', ':', '\\'',\n", + " '\\\"', '-', '}', '{', '&', '|', u'\\u2014' ]\n", + "\n", + "# We most likely would like to remove html markup\n", + "def cleanHtml (html):\n", + " from bs4 import BeautifulSoup\n", + " soup = BeautifulSoup(html, 'html.parser')\n", + " return soup .get_text()\n", + "\n", + "# We also want to remove special characters, quotes, etc. from each word\n", + "def cleanWord (w):\n", + " # r in r'[.,\"\\']' tells to treat \\ as a regular character \n", + " # but we need to escape ' with \\'\n", + " # any character between the brackets [] is to be removed \n", + " wn = re.sub('[,\"\\.\\'&\\|:@>*;/=]', \"\", w)\n", + " # get rid of numbers\n", + " return re.sub('^[0-9\\.]*$', \"\", wn)\n", + " \n", + "# define a function to get text/clean/calculate frequency\n", + "def get_wf (URL):\n", + " # first get the web page\n", + " r = requests .get(URL)\n", + " \n", + " # Now clean\n", + " # remove html markup\n", + " t = cleanHtml (r .text) .lower()\n", + " \n", + " # split string into an array of words using any sequence of spaces \"\\s+\" \n", + " wds = re .split('\\s+',t)\n", + " \n", + " # remove periods, commas, etc stuck to the edges of words\n", + " for i in range(len(wds)):\n", + " wds [i] = cleanWord (wds [i])\n", + " \n", + " # If satisfied with results, lets go to the next step: calculate frequencies\n", + " # We can write a loop to create a dictionary, but \n", + " # there is a special function for everything in python\n", + " # in particular for counting frequencies (like function table() in R)\n", + " wf = Counter (wds)\n", + " \n", + " # Remove stop words from the dictionary wf\n", + " for k in stop_words:\n", + " wf. pop(k, None)\n", + " \n", + " #how many regular words in the document?\n", + " tw = 0\n", + " for w in wf:\n", + " tw += wf[w] \n", + " \n", + " \n", + " # Get ordered list\n", + " wfs = sorted (wf .items(), key = operator.itemgetter(1), reverse=True)\n", + " ml = min(len(wfs),15)\n", + "\n", + " #Reverse the list because barh plots items from the bottom\n", + " return (wfs [ 0:ml ] [::-1], tw)\n", + " \n", + "# Now populate two lists \n", + "(wf_ee, tw_ee) = get_wf('https://www.gutenberg.org/cache/epub/1513/pg1513.txt')\n", + "(wf_bu, tw_bu) = get_wf('https://www.gutenberg.org/cache/epub/1524/pg1524.txt')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#Plot the results: are there striking differences in language?\n", + "import numpy as np\n", + "import pylab\n", + "import matplotlib.pyplot as plt\n", + "\n", + "%matplotlib inline\n", + "def plotTwoLists (wf_ee, wf_bu, title):\n", + " f = plt.figure (figsize=(10, 6))\n", + " # this is painfully tedious....\n", + " f .suptitle (title, fontsize=20)\n", + " ax = f.add_subplot(111)\n", + " ax .spines ['top'] .set_color ('none')\n", + " ax .spines ['bottom'] .set_color ('none')\n", + " ax .spines ['left'] .set_color ('none')\n", + " ax .spines ['right'] .set_color ('none')\n", + " ax .tick_params (labelcolor='w', top='off', bottom='off', left='off', right='off', labelsize=20)\n", + "\n", + " # Create two subplots, this is the first one\n", + " ax1 = f .add_subplot (121)\n", + " plt .subplots_adjust (wspace=.5)\n", + "\n", + " pos = np .arange (len(wf_ee)) \n", + " ax1 .tick_params (axis='both', which='major', labelsize=14)\n", + " pylab .yticks (pos, [ x [0] for x in wf_ee ])\n", + " ax1 .barh (range(len(wf_ee)), [ x [1] for x in wf_ee ], align='center')\n", + "\n", + " ax2 = f .add_subplot (122)\n", + " ax2 .tick_params (axis='both', which='major', labelsize=14)\n", + " pos = np .arange (len(wf_bu)) \n", + " pylab .yticks (pos, [ x [0] for x in wf_bu ])\n", + " ax2 .barh (range (len(wf_bu)), [ x [1] for x in wf_bu ], align='center')\n", + "\n", + "plotTwoLists (wf_ee, wf_bu, 'Difference between Romeo and Juliet and Hamlet')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "and\t2836\n", + "of\t2676\n", + "to\t2646\n", + "a\t2217\n", + "in\t1422\n", + "his\t1205\n", + "he\t928\n", + "that\t920\n", + "was\t823\n", + "for\t798\n", + "with\t797\n", + "as\t672\n", + "I\t505\n", + "you\t497\n" + ] + } + ], + "source": [ + "#In case Project gutenberg is blocked you can download text to your laptop and copy to the docker container via scp\n", + "#Assuming the file name you copy is pg4680.txt here is how you change the script\n", + "# Please note the option errors='replace'\n", + "# without it python invariably runs into unicode errors\n", + "f = open ('pg4680.txt', 'r', encoding=\"ascii\", errors='replace')\n", + " \n", + "# What comes back includes headers and other HTTP stuff, get just the body of the response\n", + "t = f.read()\n", + "\n", + "# obtain words by splitting a string using as separator one or more (+) space/like characters (\\s) \n", + "wds = re.split('\\s+',t)\n", + "\n", + "# now populate a dictionary (wf)\n", + "wf = {}\n", + "for w in wds:\n", + " if w in wf: wf [w] = wf [w] + 1\n", + " else: wf [w] = 1\n", + "\n", + "# dictionaries can not be sorted, so lets get a sorted *list* \n", + "wfs = sorted (wf .items(), key = operator .itemgetter (1), reverse=True) \n", + "\n", + "# lets just have no more than 15 words \n", + "ml = min(len(wfs),15)\n", + "for i in range(1,ml,1):\n", + " print (wfs[i][0]+\"\\t\"+str(wfs[i][1])) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}