1. Language Processing and Python (2024)

1.1Getting Started with Python

One of the friendly things about Python is that it allows youto type directly into the interactive interpreter —the program that will be running your Python programs.You can access the Python interpreter using a simple graphical interfacecalled the Interactive DeveLopment Environment (IDLE).On a Mac you can find this under Applications→MacPython,and on Windows under All Programs→Python.Under Unix you can run Python from the shell by typing idle(if this is not installed, try typing python).The interpreter will print a blurb about your Python version;simply check that you are running Python 3.2 or later(here it is for 3.4.2):

Python 3.4.2 (default, Oct 15 2014, 22:01:37)[GCC 4.2.1 Compatible Apple LLVM 5.1 (clang-503.0.40)] on darwinType "help", "copyright", "credits" or "license" for more information.>>>

The >>> prompt indicates that the Python interpreter is now waitingfor input. When copying examples from this book, don't typethe ">>>" yourself. Now, let's begin by using Python as a calculator:

>>> 1 + 5 * 2 - 38>>>

Once the interpreter has finished calculating the answer and displaying it, theprompt reappears. This means the Python interpreter is waiting for another instruction.

The preceding examples demonstrate how you can work interactively with thePython interpreter, experimenting with various expressions in the languageto see what they do.Now let's try a nonsensical expression to see how the interpreter handles it:

>>> 1 + File "<stdin>", line 1 1 + ^SyntaxError: invalid syntax>>>

This produced a syntax error. In Python, it doesn't make senseto end an instruction with a plus sign. The Python interpreterindicates the line where the problem occurred (line 1 of <stdin>,which stands for "standard input").

Now that we can use the Python interpreter, we're ready to start workingwith language data.

1.2Getting Started with NLTK

Before going further you should install NLTK 3.0, downloadable for free from http://nltk.org/.Follow the instructions there to download the version required for your platform.

Once you've installed NLTK, start up the Python interpreter asbefore, and install the data required for the book bytyping the following two commands at the Python prompt, then selectingthe book collection as shown in 1.1.

>>> import nltk>>> nltk.download()

Once the data is downloaded to your machine, you can load some of itusing the Python interpreter.The first step is to type a special command at thePython prompt which tells the interpreter to load some texts for us toexplore: from nltk.book import *.This says "from NLTK's book module, loadall items." The book module contains all the data you will needas you read this chapter. After printing a welcome message, it loadsthe text of several books (this will take a few seconds). Here's thecommand again, together with the output thatyou will see. Take care to get spelling and punctuation right, andremember that you don't type the >>>.

>>> from nltk.book import **** Introductory Examples for the NLTK Book ***Loading text1, ..., text9 and sent1, ..., sent9Type the name of the text or sentence to view it.Type: 'texts()' or 'sents()' to list the materials.text1: Moby Dick by Herman Melville 1851text2: Sense and Sensibility by Jane Austen 1811text3: The Book of Genesistext4: Inaugural Address Corpustext5: Chat Corpustext6: Monty Python and the Holy Grailtext7: Wall Street Journaltext8: Personals Corpustext9: The Man Who Was Thursday by G . K . Chesterton 1908>>>

Any time we want to find out about these texts, we just haveto enter their names at the Python prompt:

>>> text1<Text: Moby Dick by Herman Melville 1851>>>> text2<Text: Sense and Sensibility by Jane Austen 1811>>>>

Now that we can use the Python interpreter, and have some data to work with,we're ready to get started.

1.3Searching Text

There are many ways to examine the context of a text apart fromsimply reading it. A concordance view shows us every occurrence of a given word, togetherwith some context. Here we look up the word monstrous in MobyDick by entering text1 followed by a period, then the termconcordance, and then placing "monstrous" in parentheses:

>>> text1.concordance("monstrous")Displaying 11 of 11 matches:ong the former , one was of a most monstrous size . ... This came towards us ,ON OF THE PSALMS . " Touching that monstrous bulk of the whale or ork we have rll over with a heathenish array of monstrous clubs and spears . Some were thickd as you gazed , and wondered what monstrous cannibal and savage could ever havthat has survived the flood ; most monstrous and most mountainous ! That Himmalthey might scout at Moby Dick as a monstrous fable , or still worse and more deth of Radney .'" CHAPTER 55 Of the monstrous Pictures of Whales . I shall ere ling Scenes . In connexion with the monstrous pictures of whales , I am stronglyere to enter upon those still more monstrous stories of them which are to be foght have been rummaged out of this monstrous cabinet there is no telling . Butof Whale - Bones ; for Whales of a monstrous size are oftentimes cast up dead u>>>

The first time you use a concordance on a particular text, it takes afew extra seconds to build an index so that subsequent searches are fast.

Once you've spent a little while examining these texts, we hope you have a newsense of the richness and diversity of language. In the next chapteryou will learn how to access a broader range of text, including text inlanguages other than English.

A concordance permits us to see words in context. For example, we saw thatmonstrous occurred in contexts such as the ___ picturesand a ___ size . What other words appear in a similar rangeof contexts? We can find outby appending the term similar to the name of the text inquestion, then inserting the relevant word in parentheses:

>>> text1.similar("monstrous")mean part maddens doleful gamesome subtly uncommon careful untowardexasperate loving passing mouldy christian few true mystifyingimperial modifies contemptible>>> text2.similar("monstrous")very heartily so exceedingly remarkably as vast a great amazinglyextremely good sweet>>>

Observe that we get different results for different texts.Austen uses this word quite differently from Melville; for her, monstrous haspositive connotations, and sometimes functions as an intensifier like the wordvery.

The term common_contexts allows us to examine just thecontexts that are shared by two or more words, such as monstrousand very. We have to enclose these words by square brackets aswell as parentheses, and separate them with a comma:

>>> text2.common_contexts(["monstrous", "very"])a_pretty is_pretty am_glad be_glad a_lucky>>>

It is one thing to automatically detect that a particular word occurs in a text,and to display some words that appear in the same context. However, we can also determinethe location of a word in the text: how many words from the beginning it appears.This positional information can be displayed using a dispersion plot.Each stripe represents an instanceof a word, and each row represents the entire text. In 1.2 wesee some striking patterns of word usage over the last 220 years(in an artificial text constructed by joiningthe texts of the Inaugural Address Corpus end-to-end).You can produce this plot as shown below.You might like to try more words (e.g., liberty, constitution),and different texts. Can you predict thedispersion of a word before you view it? As before, takecare to get the quotes, commas, brackets and parentheses exactly right.

>>> text4.dispersion_plot(["citizens", "democracy", "freedom", "duties", "America"])>>>

Now, just for fun, let's try generating some random text in the variousstyles we have just seen. To do this, we type the name of the textfollowed by the term generate. (We need to include theparentheses, but there's nothing that goes between them.)

>>> text3.generate()In the beginning of his brother is a hairy man , whose top may reachunto heaven ; and ye shall sow the land of Egypt there was no bread inall that he was taken out of the month , upon the earth . So shall thywages be ? And they made their father ; and Isaac was old , and kissedhim : and Laban with his cattle in the midst of the hands of Esau thyfirst born , and Phichol the chief butler unto his son Isaac , she>>>

1.4Counting Vocabulary

The most obvious fact about texts that emerges from the preceding examples is thatthey differ in the vocabulary they use. In this section we will see how to use thecomputer to count the words in a text in a variety of useful ways.As before, you will jump right in and experiment withthe Python interpreter, even though you may not have studied Python systematicallyyet. Test your understanding by modifying the examples, and trying theexercises at the end of the chapter.

Let's begin by finding out the length of a text from start to finish,in terms of the words and punctuation symbols that appear. We use theterm len to get the length of something, which we'll apply here to thebook of Genesis:

>>> len(text3)44764>>>

So Genesis has 44,764 words and punctuation symbols, or "tokens."A token is the technical name for a sequence of characters— such as hairy, his, or :) — that we want to treat as agroup. When we count the number of tokens in a text, say, the phraseto be or not to be, we are counting occurrences of thesesequences. Thus, in our example phrase there are two occurrences of to,two of be, and one each of or and not. But there areonly four distinct vocabulary items in this phrase.How many distinct words does the book of Genesis contain?To work this out in Python, we have to pose the question slightlydifferently. The vocabulary of a text is just the set of tokensthat it uses, since in a set, all duplicates are collapsedtogether. In Python we can obtain the vocabulary items of text3 with thecommand: set(text3). When you do this, many screens of words willfly past. Now try the following:

>>> sorted(set(text3)) ['!', "'", '(', ')', ',', ',)', '.', '.)', ':', ';', ';)', '?', '?)','A', 'Abel', 'Abelmizraim', 'Abidah', 'Abide', 'Abimael', 'Abimelech','Abr', 'Abrah', 'Abraham', 'Abram', 'Accad', 'Achbor', 'Adah', ...]>>> len(set(text3)) 2789>>>

By wrapping sorted() around the Python expression set(text3), we obtain a sorted list of vocabulary items, beginningwith various punctuation symbols and continuing with words starting with A. Allcapitalized words precede lowercase words.We discover the size of the vocabulary indirectly, by askingfor the number of items in the set, and again we can use len toobtain this number . Although it has 44,764 tokens, this bookhas only 2,789 distinct words, or "word types."A word type is the form or spelling of the word independently of itsspecific occurrences in a text — that is, theword considered as a unique item of vocabulary. Our count of 2,789 itemswill include punctuation symbols, so we will generally call theseunique items types instead of word types.

Now, let's calculate a measure of the lexicalrichness of the text. The next example shows us that the number ofdistinct words is just 6% of the total number of words, or equivalentlythat each word is used 16 times on average(remember if you're using Python 2, to start with from __future__ import division).

>>> len(set(text3)) / len(text3)0.06230453042623537>>>

Next, let's focus on particular words. We can count how often a word occursin a text, and compute what percentage of the text is taken up by a specific word:

>>> text3.count("smote")5>>> 100 * text4.count('a') / len(text4)1.4643016433938312>>>

You may want to repeat such calculations on several texts,but it is tedious to keep retyping the formula. Instead,you can come up with your own name for a task, like"lexical_diversity" or "percentage", and associate it with a block of code.Now you only have to type a shortname instead of one or more complete lines of Python code, andyou can re-use it as often as you like. The block of code that does atask for us is called a function, andwe define a short name for our function with the keyword def. Thenext example shows how to define two new functions,lexical_diversity() and percentage():

>>> def lexical_diversity(text): ...  return len(set(text)) / len(text) ...>>> def percentage(count, total): ...  return 100 * count / total...

In the definition of lexical_diversity() , wespecify a parameter named text . This parameter isa "placeholder" for the actual text whose lexical diversity we want tocompute, and reoccurs in the block of code that will run when thefunction is used . Similarly, percentage() is defined totake two parameters, named count and total .

Once Python knows that lexical_diversity() and percentage()are the names for specific blocksof code, we can go ahead and use these functions:

>>> lexical_diversity(text3)0.06230453042623537>>> lexical_diversity(text5)0.13477005109975562>>> percentage(4, 5)80.0>>> percentage(text4.count('a'), len(text4))1.4643016433938312>>>

To recap, we use or call a function such as lexical_diversity() by typing its name, followedby an open parenthesis, the name of the text, and then a closeparenthesis. These parentheses will show up often; their role is to separatethe name of a task — such as lexical_diversity() — from the datathat the task is to be performed on — such as text3.The data value that we place in the parentheses when we call afunction is an argument to the function.

You have already encountered several functions in this chapter, suchas len(), set(), and sorted(). By convention, we willalways add an empty pair of parentheses after a function name, as inlen(), just to make clear that what we are talking about is afunction rather than some other kind of Python expression.Functions are an important concept in programming, and we onlymention them at the outset to give newcomers a sense of thepower and creativity of programming. Don't worry if you find it a bitconfusing right now.

Later we'll see how to use functions when tabulating data, as in 1.1.Each row of the table will involve the same computation butwith different data, and we'll do this repetitive work using a function.

Table 1.1:

Lexical Diversity of Various Genres in the Brown Corpus

2.1Lists

What is a text? At one level, it is a sequence of symbols on a page suchas this one. At another level, it is a sequence of chapters, made upof a sequence of sections, where each section is a sequence of paragraphs,and so on. However, for our purposes, we will think of a text as nothingmore than a sequence of words and punctuation. Here's how we representtext in Python, in this case the opening sentence of Moby Dick:

>>> sent1 = ['Call', 'me', 'Ishmael', '.']>>>

After the prompt we've given a name we made up, sent1, followedby the equals sign, and then some quoted words, separated withcommas, and surrounded with brackets. This bracketed materialis known as a list in Python: it is how we store a text.We can inspect it by typing the name . We can ask for its length .We can even apply our own lexical_diversity() function to it .

>>> sent1 ['Call', 'me', 'Ishmael', '.']>>> len(sent1) 4>>> lexical_diversity(sent1) 1.0>>>

Some more lists have been defined for you,one for the opening sentence of each of our texts,sent2 … sent9. We inspect two of themhere; you can see the rest for yourself using the Python interpreter(if you get an error which says that sent2 is not defined, youneed to first type from nltk.book import *).

>>> sent2['The', 'family', 'of', 'Dashwood', 'had', 'long','been', 'settled', 'in', 'Sussex', '.']>>> sent3['In', 'the', 'beginning', 'God', 'created', 'the','heaven', 'and', 'the', 'earth', '.']>>>

A pleasant surprise is that we can use Python's addition operator on lists.Adding two lists creates a new listwith everything from the first list, followedby everything from the second list:

>>> ['Monty', 'Python'] + ['and', 'the', 'Holy', 'Grail'] ['Monty', 'Python', 'and', 'the', 'Holy', 'Grail']>>>

We don't have to literally type the lists either; we can use shortnames that refer to pre-defined lists.

>>> sent4 + sent1['Fellow', '-', 'Citizens', 'of', 'the', 'Senate', 'and', 'of', 'the','House', 'of', 'Representatives', ':', 'Call', 'me', 'Ishmael', '.']>>>

What if we want to add a single item to a list? This is known as appending.When we append() to a list, the list itself is updated as a resultof the operation.

>>> sent1.append("Some")>>> sent1['Call', 'me', 'Ishmael', '.', 'Some']>>>

2.2Indexing Lists

As we have seen, a text in Python is a list of words, representedusing a combination of brackets and quotes. Just as with an ordinarypage of text, we can count up the total number of words in text1with len(text1), and count the occurrences in a text of aparticular word — say, 'heaven' — using text1.count('heaven').

With some patience, we can pick out the 1st, 173rd, or even 14,278thword in a printed text. Analogously, we can identify the elements of aPython list by their order of occurrence in the list. The number thatrepresents this position is the item's index. We instruct Pythonto show us the item that occurs at an index such as 173 in a textby writing the name of the text followed by the index inside square brackets:

>>> text4[173]'awaken'>>>

We can do the converse; given a word, find the index of when it firstoccurs:

>>> text4.index('awaken')173>>>

Indexes are a common way to access the words of a text,or, more generally, the elements of any list.Python permits us to access sublists as well, extractingmanageable pieces of language from large texts, a techniqueknown as slicing.

>>> text5[16715:16735]['U86', 'thats', 'why', 'something', 'like', 'gamefly', 'is', 'so', 'good','because', 'you', 'can', 'actually', 'play', 'a', 'full', 'game', 'without','buying', 'it']>>> text6[1600:1625]['We', "'", 're', 'an', 'anarcho', '-', 'syndicalist', 'commune', '.', 'We','take', 'it', 'in', 'turns', 'to', 'act', 'as', 'a', 'sort', 'of', 'executive','officer', 'for', 'the', 'week']>>>

Indexes have some subtleties, and we'll explore these withthe help of an artificial sentence:

>>> sent = ['word1', 'word2', 'word3', 'word4', 'word5',...  'word6', 'word7', 'word8', 'word9', 'word10']>>> sent[0]'word1'>>> sent[9]'word10'>>>

Notice that our indexes start from zero: sent element zero, written sent[0],is the first word, 'word1', whereas sent element 9 is 'word10'.The reason is simple: the moment Python accesses the content of a list fromthe computer's memory, it is already at the first element;we have to tell it how many elements forward to go.Thus, zero steps forward leaves it at the first element.

Now, if we accidentally use an index that is too large, we get an error:

>>> sent[10]Traceback (most recent call last): File "<stdin>", line 1, in ?IndexError: list index out of range>>>

This time it is not a syntax error, because the program fragment is syntactically correct.Instead, it is a runtime error, and it produces a Traceback message thatshows the context of the error, followed by the name of the error,IndexError, and a brief explanation.

Let's take a closer look at slicing, using our artificial sentence again.Here we verify that the slice 5:8 includes sent elements atindexes 5, 6, and 7:

>>> sent[5:8]['word6', 'word7', 'word8']>>> sent[5]'word6'>>> sent[6]'word7'>>> sent[7]'word8'>>>

By convention, m:n means elements m…n-1.As the next example shows,we can omit the first number if the slice begins at the start of thelist , and we can omit the second number if the slice goes to the end :

>>> sent[:3] ['word1', 'word2', 'word3']>>> text2[141525:] ['among', 'the', 'merits', 'and', 'the', 'happiness', 'of', 'Elinor', 'and', 'Marianne',',', 'let', 'it', 'not', 'be', 'ranked', 'as', 'the', 'least', 'considerable', ',','that', 'though', 'sisters', ',', 'and', 'living', 'almost', 'within', 'sight', 'of','each', 'other', ',', 'they', 'could', 'live', 'without', 'disagreement', 'between','themselves', ',', 'or', 'producing', 'coolness', 'between', 'their', 'husbands', '.','THE', 'END']>>>

We can modify an element of a list by assigning to one of its index values.In the next example, we put sent[0] on the left of the equals sign . We can alsoreplace an entire slice with new material . A consequence of thislast change is that the list only has four elements, and accessing a later valuegenerates an error .

>>> sent[0] = 'First' >>> sent[9] = 'Last'>>> len(sent)10>>> sent[1:9] = ['Second', 'Third'] >>> sent['First', 'Second', 'Third', 'Last']>>> sent[9] Traceback (most recent call last): File "<stdin>", line 1, in ?IndexError: list index out of range>>>

2.3Variables

From the start of 1, you have hadaccess to texts called text1, text2, and so on. It saved a lotof typing to be able to refer to a 250,000-word book with a short namelike this! In general, we can make up names for anything we careto calculate. We did this ourselves in the previous sections, e.g.,defining a variable sent1, as follows:

>>> sent1 = ['Call', 'me', 'Ishmael', '.']>>>

Such lines have the form: variable = expression. Python will evaluatethe expression, and save its result to the variable. This process iscalled assignment. It does not generate any output;you have to type the variable on a line of itsown to inspect its contents. The equals sign is slightly misleading,since information is moving from the right side to the left.It might help to think of it as a left-arrow.The name of the variable can be anything you like, e.g., my_sent, sentence, xyzzy.It must start with a letter, and can include numbers and underscores.Here are some examples of variables and assignments:

>>> my_sent = ['Bravely', 'bold', 'Sir', 'Robin', ',', 'rode',... 'forth', 'from', 'Camelot', '.']>>> noun_phrase = my_sent[1:4]>>> noun_phrase['bold', 'Sir', 'Robin']>>> wOrDs = sorted(noun_phrase)>>> wOrDs['Robin', 'Sir', 'bold']>>>

Remember that capitalized words appear before lowercase words in sorted lists.

It is good to choose meaningful variable names to remind you — and to help anyoneelse who reads your Python code — what your code is meant to do.Python does not try to make sense of the names; it blindly follows your instructions,and does not object if you do something confusing, such as one = 'two' or two = 3.The only restriction is thata variable name cannot be any of Python's reserved words, such asdef, if, not,and import. If you use a reserved word, Python will produce a syntax error:

>>> not = 'Camelot' File "<stdin>", line 1 not = 'Camelot' ^SyntaxError: invalid syntax>>>

We will often use variables to hold intermediate steps of a computation, especiallywhen this makes the code easier to follow. Thus len(set(text1)) could also be written:

>>> vocab = set(text1)>>> vocab_size = len(vocab)>>> vocab_size19317>>>

2.4Strings

Some of the methods we used to access the elements of a list also work with individual words,or strings. For example, we can assign a string to a variable ,index a string , and slice a string :

>>> name = 'Monty' >>> name[0] 'M'>>> name[:4] 'Mont'>>>

We can also perform multiplication and addition with strings:

>>> name * 2'MontyMonty'>>> name + '!''Monty!'>>>

We can join the words of a list to make a single string, or split a string into a list, as follows:

>>> ' '.join(['Monty', 'Python'])'Monty Python'>>> 'Monty Python'.split()['Monty', 'Python']>>>

We will come back to the topic of strings in 3.For the time being, we have two important building blocks— lists and strings —and are ready to get back to some language analysis.

3.1Frequency Distributions

How can we automatically identify the words of a text that are mostinformative about the topic and genre of the text? Imagine how you mightgo about finding the 50 most frequent words of a book. One methodwould be to keep a tally for each vocabulary item, like that shown in 3.1.The tally would need thousands of rows, and it would be an exceedinglylaborious process — so laborious that we would rather assign the task to a machine.

The table in 3.1 is known as a frequency distribution,and it tells us the frequency of each vocabulary item in the text.(In general, it could count any kind of observable event.)It is a "distribution"because it tells us how the total number of word tokens in the textare distributed across the vocabulary items.Since we often need frequency distributions in language processing, NLTKprovides built-in support for them. Let's use a FreqDist to find the50 most frequent words of Moby Dick:

>>> fdist1 = FreqDist(text1) >>> print(fdist1) <FreqDist with 19317 samples and 260819 outcomes>>>> fdist1.most_common(50) [(',', 18713), ('the', 13721), ('.', 6862), ('of', 6536), ('and', 6024),('a', 4569), ('to', 4542), (';', 4072), ('in', 3916), ('that', 2982),("'", 2684), ('-', 2552), ('his', 2459), ('it', 2209), ('I', 2124),('s', 1739), ('is', 1695), ('he', 1661), ('with', 1659), ('was', 1632),('as', 1620), ('"', 1478), ('all', 1462), ('for', 1414), ('this', 1280),('!', 1269), ('at', 1231), ('by', 1137), ('but', 1113), ('not', 1103),('--', 1070), ('him', 1058), ('from', 1052), ('be', 1030), ('on', 1005),('so', 918), ('whale', 906), ('one', 889), ('you', 841), ('had', 767),('have', 760), ('there', 715), ('But', 705), ('or', 697), ('were', 680),('now', 646), ('which', 640), ('?', 637), ('me', 627), ('like', 624)]>>> fdist1['whale']906>>>

When we first invoke FreqDist, we pass the name of the text as anargument . We can inspect the total number of words ("outcomes")that have been counted up — 260,819 in thecase of Moby Dick. The expression most_common(50) gives us a list ofthe 50 most frequently occurring types in the text .

Do any words produced in the last example help us grasp the topic or genre of this text?Only one word, whale, is slightly informative! It occurs over 900 times.The rest of the words tell us nothing about the text; they're just English "plumbing."What proportion of the text is taken up with such words?We can generate a cumulative frequency plot for these words,using fdist1.plot(50, cumulative=True), to produce the graph in 3.2.These 50 words account for nearly half the book!

If the frequent words don't help us, how about the words that occur onceonly, the so-called hapaxes? View them by typing fdist1.hapaxes().This list contains lexicographer, cetological,contraband, expostulations, and about 9,000 others.It seems that there are too many rare words, and without seeing thecontext we probably can't guess what half of the hapaxes mean in any case!Since neither frequent nor infrequent words help, we need to trysomething else.

3.2Fine-grained Selection of Words

Next, let's look at the long words of a text; perhaps these will bemore characteristic and informative. For this we adapt some notationfrom set theory. We would like to find the words from the vocabularyof the text that are more than 15 characters long. Let's callthis property P, so that P(w) is trueif and only if w is more than 15 characters long.Now we can express the words of interest using mathematicalset notation as shown in (1a).This means "the set of all w such that w is anelement of V (the vocabulary) and w has property P".

The corresponding Python expression is given in (1b).(Note that it produces a list, not a set, which means that duplicates are possible.)Observe how similar the two notations are. Let's go one more step andwrite executable Python code:

>>> V = set(text1)>>> long_words = [w for w in V if len(w) > 15]>>> sorted(long_words)['CIRCUMNAVIGATION', 'Physiognomically', 'apprehensiveness', 'cannibalistically','characteristically', 'circumnavigating', 'circumnavigation', 'circumnavigations','comprehensiveness', 'hermaphroditical', 'indiscriminately', 'indispensableness','irresistibleness', 'physiognomically', 'preternaturalness', 'responsibilities','simultaneousness', 'subterraneousness', 'supernaturalness', 'superstitiousness','uncomfortableness', 'uncompromisedness', 'undiscriminating', 'uninterpenetratingly']>>>

For each word w in the vocabulary V, we check whetherlen(w) is greater than 15; all other words willbe ignored. We will discuss this syntax more carefully later.

Let's return to our task of finding words that characterize a text.Notice that the long words in text4 reflect its national focus— constitutionally, transcontinental —whereas those in text5 reflect its informal content:boooooooooooglyyyyyy and yuuuuuuuuuuuummmmmmmmmmmm.Have we succeeded in automatically extracting words that typifya text? Well, these very long words are often hapaxes (i.e., unique)and perhaps it would be better to find frequently occurringlong words. This seems promising since it eliminatesfrequent short words (e.g., the) and infrequent long words(e.g. antiphilosophists).Here are all words from the chat corpusthat are longer than seven characters, that occur more than seven times:

>>> fdist5 = FreqDist(text5)>>> sorted(w for w in set(text5) if len(w) > 7 and fdist5[w] > 7)['#14-19teens', '#talkcity_adults', '((((((((((', '........', 'Question','actually', 'anything', 'computer', 'cute.-ass', 'everyone', 'football','innocent', 'listening', 'remember', 'seriously', 'something', 'together','tomorrow', 'watching']>>>

Notice how we have used two conditions: len(w) > 7 ensures that thewords are longer than seven letters, and fdist5[w] > 7 ensures thatthese words occur more than seven times. At last we have managed toautomatically identify the frequently-occurring content-bearingwords of the text. It is a modest but important milestone: a tiny piece of code,processing tens of thousands of words, produces some informative output.

3.3Collocations and Bigrams

A collocation is a sequence of words that occur togetherunusually often. Thus red wine is a collocation, whereas thewine is not. A characteristic of collocations is that they areresistant to substitution with words that have similar senses;for example, maroon wine sounds definitely odd.

To get a handle on collocations, we start off by extracting from a texta list of word pairs, also known as bigrams. This is easilyaccomplished with the function bigrams():

>>> list(bigrams(['more', 'is', 'said', 'than', 'done']))[('more', 'is'), ('is', 'said'), ('said', 'than'), ('than', 'done')]>>>

Here we see that the pair of words than-done is a bigram, and we writeit in Python as ('than', 'done'). Now, collocations are essentiallyjust frequent bigrams, except that we want to pay more attention to thecases that involve rare words. In particular, we want to findbigrams that occur more often than we would expect based onthe frequency of the individual words. The collocations() functiondoes this for us. We will see how it works later.

>>> text4.collocations()United States; fellow citizens; four years; years ago; FederalGovernment; General Government; American people; Vice President; OldWorld; Almighty God; Fellow citizens; Chief Magistrate; Chief Justice;God bless; every citizen; Indian tribes; public debt; one another;foreign nations; political parties>>> text8.collocations()would like; medium build; social drinker; quiet nights; non smoker;long term; age open; Would like; easy going; financially secure; funtimes; similar interests; Age open; weekends away; poss rship; wellpresented; never married; single mum; permanent relationship; slimbuild>>>

The collocations that emerge are very specific to the genre of thetexts. In order to find red wine as a collocation, we wouldneed to process a much larger body of text.

3.4Counting Other Things

Counting words is useful, but we can count other things too. For example, we canlook at the distribution of word lengths in a text, by creating a FreqDistout of a long list of numbers, where each number is the length of the correspondingword in the text:

>>> [len(w) for w in text1] [1, 4, 4, 2, 6, 8, 4, 1, 9, 1, 1, 8, 2, 1, 4, 11, 5, 2, 1, 7, 6, 1, 3, 4, 5, 2, ...]>>> fdist = FreqDist(len(w) for w in text1) >>> print(fdist) <FreqDist with 19 samples and 260819 outcomes>>>> fdistFreqDist({3: 50223, 1: 47933, 4: 42345, 2: 38513, 5: 26597, 6: 17111, 7: 14399, 8: 9966, 9: 6428, 10: 3528, ...})>>>

We start by deriving a list of the lengths of words in text1,and the FreqDist then counts the number of times each of theseoccurs . The result is a distribution containinga quarter of a million items, each of which is a number corresponding to aword token in the text. But there are at most only 20 distinctitems being counted, the numbers 1 through 20, because there are only 20different word lengths. I.e., there are words consisting of just one character,two characters, ..., twenty characters, but none with twenty one or morecharacters. One might wonder how frequent the different lengths of word are(e.g., how many words of length four appear in the text, are there more words of length fivethan length four, etc). We can do this as follows:

>>> fdist.most_common()[(3, 50223), (1, 47933), (4, 42345), (2, 38513), (5, 26597), (6, 17111), (7, 14399),(8, 9966), (9, 6428), (10, 3528), (11, 1873), (12, 1053), (13, 567), (14, 177),(15, 70), (16, 22), (17, 12), (18, 1), (20, 1)]>>> fdist.max()3>>> fdist[3]50223>>> fdist.freq(3)0.19255882431878046>>>

From this we see that the most frequent word length is 3, and thatwords of length 3 account for roughly 50,000 (or 20%) of the words making up thebook. Although we will not pursue it here, further analysis of wordlength might help us understand differences between authors, genres, orlanguages.

3.1 summarizes the functions defined in frequency distributions.

Table 3.1:

Functions Defined for NLTK's Frequency Distributions

Our discussion of frequency distributions has introduced some important Python concepts,and we will look at them systematically in 4.

4.1Conditionals

Python supports a wide range of operators, such as < and >=, fortesting the relationship between values. The full set of these relationaloperators is shown in 4.1.

Table 4.1:

Numerical Comparison Operators

We can use these to select different words from a sentence of news text.Here are some examples — only the operator is changed from oneline to the next. They all use sent7, the first sentence from text7(Wall Street Journal). As before, if you get an error saying that sent7is undefined, you need to first type: from nltk.book import *

>>> sent7['Pierre', 'Vinken', ',', '61', 'years', 'old', ',', 'will', 'join', 'the','board', 'as', 'a', 'nonexecutive', 'director', 'Nov.', '29', '.']>>> [w for w in sent7 if len(w) < 4][',', '61', 'old', ',', 'the', 'as', 'a', '29', '.']>>> [w for w in sent7 if len(w) <= 4][',', '61', 'old', ',', 'will', 'join', 'the', 'as', 'a', 'Nov.', '29', '.']>>> [w for w in sent7 if len(w) == 4]['will', 'join', 'Nov.']>>> [w for w in sent7 if len(w) != 4]['Pierre', 'Vinken', ',', '61', 'years', 'old', ',', 'the', 'board','as', 'a', 'nonexecutive', 'director', '29', '.']>>>

There is a common pattern to all of these examples:[w for w in text if condition ], where condition is aPython "test" that yields either true or false.In the cases shown in the previous code example, the condition is always a numerical comparison.However, we can also test various properties of words,using the functions listed in 4.2.

Table 4.2:

Some Word Comparison Operators

Here are some examples of these operators being used toselect words from our texts:words ending with -ableness;words containing gnt;words having an initial capital;and words consisting entirely of digits.

>>> sorted(w for w in set(text1) if w.endswith('ableness'))['comfortableness', 'honourableness', 'immutableness', 'indispensableness', ...]>>> sorted(term for term in set(text4) if 'gnt' in term)['Sovereignty', 'sovereignties', 'sovereignty']>>> sorted(item for item in set(text6) if item.istitle())['A', 'Aaaaaaaaah', 'Aaaaaaaah', 'Aaaaaah', 'Aaaah', 'Aaaaugh', 'Aaagh', ...]>>> sorted(item for item in set(sent7) if item.isdigit())['29', '61']>>>

We can also create more complex conditions. If c is acondition, then not c is also a condition.If we have two conditions c₁ and c₂,then we can combine them to form a new condition using conjunction and disjunction:c₁ and c₂,c₁ or c₂.

>>> sorted(w for w in set(text7) if '-' in w and 'index' in w)>>> sorted(wd for wd in set(text3) if wd.istitle() and len(wd) > 10)>>> sorted(w for w in set(sent7) if not w.islower())>>> sorted(t for t in set(text2) if 'cie' in t or 'cei' in t)

4.2Operating on Every Element

In 3, we saw some examples ofcounting items other than words. Let's take a closer look at the notation we used:

>>> [len(w) for w in text1][1, 4, 4, 2, 6, 8, 4, 1, 9, 1, 1, 8, 2, 1, 4, 11, 5, 2, 1, 7, 6, 1, 3, 4, 5, 2, ...]>>> [w.upper() for w in text1]['[', 'MOBY', 'DICK', 'BY', 'HERMAN', 'MELVILLE', '1851', ']', 'ETYMOLOGY', '.', ...]>>>

These expressions have the form [f(w) for ...] or [w.f() for ...], wheref is a function that operates on a word to compute its length, or toconvert it to uppercase.For now, you don't need to understand the difference between the notations f(w) andw.f(). Instead, simply learn this Python idiom which performs thesame operation on every element of a list. In the preceding examples, it goes througheach word in text1, assigning each one in turn to the variable w andperforming the specified operation on the variable.

Let's return to the question of vocabulary size, and apply the same idiom here:

>>> len(text1)260819>>> len(set(text1))19317>>> len(set(word.lower() for word in text1))17231>>>

Now that we are not double-counting words like This and this, which differ onlyin capitalization, we've wiped 2,000 off the vocabulary count! We can go a step furtherand eliminate numbers and punctuation from the vocabulary count by filtering out anynon-alphabetic items:

>>> len(set(word.lower() for word in text1 if word.isalpha()))16948>>>

This example is slightly complicated: it lowercases all the purely alphabetic items.Perhaps it would have been simpler just to count the lowercase-only items, but thisgives the wrong answer (why?).

Don't worry if you don't feel confident with list comprehensions yet,since you'll see many more examples along with explanations in the following chapters.

4.3Nested Code Blocks

Most programming languages permit us to execute a block of code when aconditional expression, or if statement, is satisfied. Wealready saw examples of conditional tests in code like [w for w insent7 if len(w) < 4]. In the following program, we have created avariable called word containing the string value 'cat'. Theif statement checks whether the test len(word) < 5 is true.It is, so the body of the if statement is invoked and theprint statement is executed, displaying a message to the user.Remember to indent the print statement by typing four spaces.

>>> word = 'cat'>>> if len(word) < 5:...  print('word length is less than 5')...  word length is less than 5>>>

When we use the Python interpreter we have to add an extra blank line in order for it to detect that the nested block is complete.

>>> from __future__ import print_function

If we change the conditional test to len(word) >= 5,to check that the length of word is greater than or equal to 5,then the test will no longer be true.This time, the body of the if statement will not be executed,and no message is shown to the user:

>>> if len(word) >= 5:...  print('word length is greater than or equal to 5')...>>>

An if statement is known as a control structurebecause it controls whether the code in the indented block will be run.Another control structure is the for loop.Try the following, and remember to include the colon and the four spaces:

>>> for word in ['Call', 'me', 'Ishmael', '.']:...  print(word)...CallmeIshmael.>>>

This is called a loop because Python executes the code incircular fashion. It starts by performing theassignment word = 'Call',effectively using the word variable to name the firstitem of the list. Then, it displays the value of wordto the user. Next, it goes back to the for statement,and performs the assignment word = 'me', before displaying this new valueto the user, and so on. It continues in this fashion untilevery item of the list has been processed.

4.4Looping with Conditions

Now we can combine the if and for statements.We will loop over every item of the list, and printthe item only if it ends with the letter l. We'll pick anothername for the variable to demonstrate that Python doesn'ttry to make sense of variable names.

>>> sent1 = ['Call', 'me', 'Ishmael', '.']>>> for xyzzy in sent1:...  if xyzzy.endswith('l'):...  print(xyzzy)...CallIshmael>>>

You will notice that if and for statementshave a colon at the end of the line,before the indentation begins. In fact, all Pythoncontrol structures end with a colon. The colonindicates that the current statement relates to theindented block that follows.

We can also specify an action to be taken ifthe condition of the if statement is not met.Here we see the elif (else if) statement, andthe else statement. Notice that these also havecolons before the indented code.

>>> for token in sent1:...  if token.islower():...  print(token, 'is a lowercase word')...  elif token.istitle():...  print(token, 'is a titlecase word')...  else:...  print(token, 'is punctuation')...Call is a titlecase wordme is a lowercase wordIshmael is a titlecase word. is punctuation>>>

As you can see, even with this small amount of Python knowledge,you can start to build multiline Python programs.It's important to develop such programs in pieces,testing that each piece does what you expect beforecombining them into a program. This is why the Pythoninteractive interpreter is so invaluable, and why you should getcomfortable using it.

Finally, let's combine the idioms we've been exploring.First, we create a list of cie and cei words,then we loop over each item and print it. Notice theextra information given in the print statement: end=' '.This tells Python to print a space (not the default newline) after each word.

>>> tricky = sorted(w for w in set(text2) if 'cie' in w or 'cei' in w)>>> for word in tricky:...  print(word, end=' ')ancient ceiling conceit conceited conceive conscienceconscientious conscientiously deceitful deceive ...>>>

5.1Word Sense Disambiguation

In word sense disambiguation we want to work outwhich sense of a word was intended in a given context. Consider theambiguous words serve and dish:

In a sentence containing the phrase: he served the dish, youcan detect that both serve and dish are being used withtheir food meanings. It's unlikely that the topic of discussionshifted from sports to crockery in the space of three words.This would force you to invent bizarre images, like a tennis protaking out his or her frustrations on a china tea-set laid out beside the court.In other words, we automatically disambiguate words using context, exploitingthe simple fact that nearby words have closely related meanings.As another example of this contextual effect, consider the wordby, which has several meanings, e.g.: the book byChesterton (agentive — Chesterton was the author of the book);the cup by the stove (locative — the stove is where thecup is); and submit by Friday (temporal — Friday is thetime of the submitting).Observe in (3c) that the meaning of the italicized word helps usinterpret the meaning of by.

5.2Pronoun Resolution

A deeper kind of language understanding is to work out "who did what to whom" —i.e., to detect the subjects and objects of verbs. You learnt to do this inelementary school, but it's harder than you might think.In the sentence the thieves stole the paintingsit is easy to tell who performed the stealing action.Consider three possible following sentences in (4c), and try to determinewhat was sold, caught, and found (one case is ambiguous).

Answering this question involves finding the antecedent of the pronoun they,either thieves or paintings. Computational techniques for tackling this probleminclude anaphora resolution — identifying what a pronoun or noun phraserefers to — and semantic role labeling — identifying how a noun phraserelates to the verb (as agent, patient, instrument, and so on).

5.3Generating Language Output

If we can automatically solve such problems of language understanding, we willbe able to move on to tasks that involve generating language output, such asquestion answering and machine translation. In the first case,a machine should be able to answer a user's questions relating to collection of texts:

The machine's answer demonstrates that it has correctly worked out that theyrefers to paintings and not to thieves. In the second case, the machine shouldbe able to translate the text into another language, accuratelyconveying the meaning of the original text. In translating the example text into French,we are forced to choose the gender of the pronoun in the second sentence:ils (masculine) if the thieves are found, and elles (feminine) ifthe paintings are found. Correct translation actually depends on correct understanding ofthe pronoun.

In all of these examples, working out the sense of a word, the subject of a verb, and theantecedent of a pronoun are steps in establishing the meaning of a sentence, thingswe would expect a language understanding system to be able to do.

5.4Machine Translation

For a long time now, machine translation (MT) hasbeen the holy grail of language understanding,ultimately seeking to provide high-quality,idiomatic translation between any pair of languages.Its roots go back to the early days of the Cold War, when the promiseof automatic translation led to substantial government sponsorship,and with it, the genesis of NLP itself.

Today, practical translation systems exist for particular pairsof languages, and some are integrated into web search engines.However, these systems have some serious shortcomings, whichare starkly revealed by translating a sentence back and forthbetween a pair of languages until equilibrium is reached, e.g.:

Observe that the system correctly translates Alice Springs from Englishto German (in the line starting 1>), but on the way back to English, this ends up as Alice jump(line 2). The preposition before is initially translated into the correspondingGerman preposition vor, but later into the conjunction bevor (line 5).After line 5 the sentences become nonsensical (but notice the various phrasingsindicated by the commas, and the change from jump to leap).The translation system did not recognize when a word was part of a proper name,and it misinterpreted the grammatical structure.

Machine translation is difficult because a given word could have several possibletranslations (depending on its meaning), and because word order must be changedin keeping with the grammatical structure of the target language.Today these difficulties are being faced by collecting massive quantities ofparallel texts from news and government websites that publish documentsin two or more languages. Given a document in German and English, and possiblya bilingual dictionary, we can automatically pair up the sentences,a process called text alignment. Once we have a million or more sentencepairs, we can detect corresponding words and phrases, and build a modelthat can be used for translating new text.

5.5Spoken Dialog Systems

In the history of artificial intelligence, the chief measure of intelligencehas been a linguistic one, namely the Turing Test: can a dialogue system,responding to a user's text input, perform so naturally that we cannot distinguish*t from a human-generated response? In contrast, today's commercial dialogue systemsare very limited, but still perform useful functions in narrowly-defined domains,as we see here:

You could not ask this system to provide driving instructions ordetails of nearby restaurants unless the required informationhad already been stored and suitable question-answer pairshad been incorporated into the language processing system.

Observe that this system seems to understand the user's goals:the user asks when a movie is showing and the systemcorrectly determines from this that the user wants to seethe movie. This inference seems so obvious that you probablydidn't notice it was made, yet a natural language systemneeds to be endowed with this capability in order to interactnaturally. Without it, when asked Do you know when Saving PrivateRyan is playing?, a system might unhelpfully respond with a cold Yes.However, the developers of commercial dialogue systems usecontextual assumptions and business logic to ensure that the different ways in which a user mightexpress requests or provide information are handled in a way thatmakes sense for the particular application. So, if you typeWhen is ..., or I want to know when ..., or Can you tell mewhen ..., simple rules will always yield screening times. This isenough for the system to provide a useful service.

Dialogue systems give us an opportunity to mention thecommonly assumed pipeline for NLP.5.1 shows the architecture of a simple dialogue system.Along the top of the diagram, moving from left to right, is a"pipeline" of some language understanding components.These map from speech input via syntactic parsingto some kind of meaning representation. Along the middle, moving fromright to left, is the reverse pipeline of components for convertingconcepts to speech. These components make up the dynamic aspects of the system.At the bottom of the diagram are some representative bodies ofstatic information: the repositories of language-related data thatthe processing components draw on to do their work.

5.6Textual Entailment

The challenge of language understanding has been brought into focus in recent years by a public"shared task" called Recognizing Textual Entailment (RTE). The basicscenario is simple. Suppose you want to find evidence to supportthe hypothesis: Sandra Goudie was defeated by Max Purnell, andthat you have another short text that seems to be relevant, for example,Sandra Goudie was first elected to Parliament in the 2002 elections,narrowly winning the seat of Coromandel by defeating Labour candidateMax Purnell and pushing incumbent Green MP Jeanette Fitzsimons intothird place. Does the text provide enough evidence for you toaccept the hypothesis? In this particular case, the answer will be "No."You can draw this conclusion easily, but it is very hard to come up withautomated methods for making the right decision. The RTEChallenges provide data that allow competitors to develop theirsystems, but not enough data for "brute force" machine learning techniques (a topicwe will cover in chap-data-intensive). Consequently, somelinguistic analysis is crucial. In the previous example, it is importantfor the system to note that Sandra Goudie names the person beingdefeated in the hypothesis, not the person doing the defeating in thetext. As another illustration of the difficulty of the task, considerthe following text-hypothesis pair:

In order to determine whether the hypothesis is supported by thetext, the system needs the following background knowledge:(i) if someone is an author of a book, then he/she has written thatbook; (ii) if someone is an editor of a book, then he/she has notwritten (all of) that book; (iii) if someone is editor or author of eighteenbooks, then one cannot conclude that he/she is author of eighteen books.

5.7Limitations of NLP

Despite the research-led advances in tasks like RTE, natural languagesystems that have been deployed for real-world applications still cannot performcommon-sense reasoning or draw on world knowledge in a general androbust manner. We can wait for these difficult artificialintelligence problems to be solved, but in the meantime it isnecessary to live with some severe limitations on the reasoning andknowledge capabilities of natural language systems. Accordingly, rightfrom the beginning, an important goal of NLP research has been tomake progress on the difficult task of building technologies that"understand language," using superficial yet powerful techniques instead ofunrestricted knowledge and reasoning capabilities.Indeed, this is one of the goals of this book, and we hope to equip you withthe knowledge and skills to build useful NLP systems, and tocontribute to the long-term aspiration of building intelligent machines.

About this document...

UPDATED FOR NLTK 3.0.This is a chapter from Natural Language Processing with Python,by Steven Bird, Ewan Klein and Edward Loper,Copyright © 2019 the authors.It is distributed with the Natural Language Toolkit [http://nltk.org/],Version 3.0, under the terms of theCreative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States License[http://creativecommons.org/licenses/by-nc-nd/3.0/us/].

This document was built onWed 4 Sep 2019 11:40:48 ACST

System Message: ERROR/3 (ch01.rst2, line 1889); backlink

Unknown target name: "finegan2007".