$34.99
Natural Language Processing Assignment 1 Solution
Introduction
In this assignment we will:
1. Go through the basics of NLTK, the most popular NLP library for python;
2. Develop and evaluate several language models;
3. Develop and evaluate a full part-‐of-‐speech tagger using Viterbi algorithm.
Environment Setup
We will assume at this point you already have a Rod account and have already used SSH to connect to the Rod server. We will also assume you have already created a hidden directory with your homework PIN number (if not, see instructions sent through email before proceeding). The following instructions should be executed while logged to the Rod server.
Step 1 – Create a link to the NLTK files, available at the course directory.
Go to your home directory:
cd ~/
Create a symbolic link to NLTK data:
ln -s ../595/nltk_data/ nltk_data
Step 2 – Copy the homework files to your hidden directory under Homework1 folder.
From your home directory, use the following command:
cp -r ../595/Homework1 ~/hidden/<YOUR_PIN/
Basic NLTK Tutorial
The Natural Language Tool Kit (NLTK) is the most popular NLP library for python. NLTK has already been installed on the Rod server, so you do not have to install it yourself. If you followed the “Environment Setup” section, you should be good to start using NLTK now.
Now let’s walk through some simple NLTK use cases that concern this assignment. For that, you will need first to open a python interactive shell. Just type python on the command line and you should see the interactive shell start.
Import the NLTK package
To use NLTK package, you must include the following line at the beginning of your code (or in this case
just type in the interactive shell):
import nltk
Tokenization
To tokenize means to break a continuous string into tokens (usually words, but a token could also be a symbol, punctuation, or other meaningful unit). In NLTK, text can be tokenized using the word_tokenize() method. It returns a list of tokens that will be the input for many methods in NLTK.
sentence = "At eight o'clock on Thursday morning on Thursday morning on Thursday morning." tokens = nltk.word_tokenize(sentence)
N-‐grams Generation
An n-‐gram (in the context of this assignment) is a contiguous sequence of n tokens in a sentence. The following code returns a list of bigrams and a list of trigrams. Each n-‐gram is represented as a tuple in python (if you are not familiar with python tuples read the python tuple doc page)
bigram_tuples = list(nltk.bigrams(tokens))
trigram_tuples = list(nltk.trigrams(tokens))
We can calculate the count of each n-‐gram using the following code:
count = {item : bigram_tuples.count(item) for item in set(bigram_tuples)}
Or we can find all the distinct n-‐grams that contain the word “on”:
ngrams = [item for item in set(bigram_tuples) if "on" in item]
If you find it hard to understand the examples above, read about list/dict comprehensions here. List/dict comprehensions are a way of executing iterations in one line that may be very useful and convenient. Besides making coding easier, learning them will also help you understand code written by other python
programmers.
Default POS Tagger (Non-‐statistical)
The most naïve way of tagging parts-‐of-‐speech is to assign the same tag to all the tokens. This is exactly what the NLTK default tagger does. Although inaccurate and arbitrary, it sets a baseline for taggers, and can be used as a default tagger when more sophisticated methods fail.
In NLTK, it’s easy to create a default tagger by indicating the default tag in the constructor.
default_tagger = nltk.DefaultTagger('NN')
tagged_sentence = default_tagger.tag(tokens)
Now we have our first tagger. NLTK can help if you need to understand the meaning of a tag.
# Show the description of the tag 'NN' nltk.help.upenn_tagset('NN')
Regular Expression POS Tagger (Non-‐statistical)
A regular expression tagger maintains a list of regular expressions paired with a tag (see the Wikipedia article for more information about regular expressions: http://en.wikipedia.org/wiki/Regular_expression). The tagger tries to match each token to one of the regular expressions in its list; the token receives the tag that is paired with the first matching regular expression. “None” is given to a token that does not match any regular expression.
To create a Regular Expression Tagger in NLTK, we provide a list of pattern-‐tag pairs to the appropriate
constructor. Example:
patterns = [(r'.*ing$', 'VBG'),(r'.*ed$', 'VBD'),(r'.*es$', 'VBZ'),(r'.*ed$', 'VB')]
regexp_tagger = nltk.RegexpTagger(patterns)
regexp_tagger.tag(tokens)
N-‐gram HMM Tagger (Statistical)
Although there are many different kinds of statistical taggers, we will only work with Hidden Markov Model (HMM) taggers in this assignment.
Like every statistical tagger, n-‐gram taggers use a set of tagged sentences, known as the training data, to create a model that is used to tag new sentences. In NLTK, a sentence of the training data must be formatted as a list of tuples, where each tuple is a pair or word-‐tag (see example below).
[('The', 'AT'), ('Fulton', 'NP-TL'), ('County', 'NN-TL')]
NLTK already provides corpora formatted this way. In particular, we are going to use the Brown corpus.
# import the corpus from NLTK and build the training set from sentences in “news”
from nltk.corpus import brown
training = brown.tagged_sents(categories='news')
# Create Unigram, Bigram, Trigram taggers based on the training set. unigram_tagger = nltk.UnigramTagger(training)
bigram_tagger = nltk.BigramTagger(training)
trigram_tagger = nltk.TrigramTagger(training)
Although we could also build 4-‐gram, 5-‐gram, etc. taggers, trigram taggers are the most popular model. This is because a trigram model is an excellent compromise between computational complexity and performance.
Combination of Taggers
A tagger fails when it cannot find a best tag sequence for a given sentence. For example, one situation when an n-‐gram tagger will fail is when it encounters an OOV (out of vocabulary) word not seen in the training data: the tagger will tag the word as ”NONE”. One way to handle tagger failure is to fall back to an alternative tagger if the primary one fails. This is called “using back off.” One can easily set a hierarchy of taggers in NLTK as follows.
default_tagger = nltk.DefaultTagger('NN')
bigram_tagger = nltk.BigramTagger(training, backoff=default_tagger)
trigram_tagger = nltk.TrigramTagger(training, backoff=bigram_tagger)
Tagging Low Frequency Words
Low frequency words are another common source of tagger failure, because an n-‐gram that contains a low frequency word and is found in the test data might not be found in the training data. One method to resolve this tagger failure is to group low frequency words. For example, we could substitute the token “_RARE_” for all words with frequency lower than 0.05% in the training data. Any words in the development data that were not found in the training data could then be treated instead as the token “_RARE_”, thereby allowing the algorithm to assign a tag. If we wanted to add another group we could substitute the string “_NUMBER_” for those rare words that represent a numeral. When tagging the test data, we could substitute “_NUMBER_” for all tokens that were unseen in the training data and represent a numeral. We will use this technique later in this assignment.
Provided Files and Report
Now let’s go back to the assignment folder you copied to your home directory (should be ~/hidden/<Your PIN/Homework1). In this assignment we will be using the Brown Corpus, which is a dataset of English sentences compiled in the 1960s. We have provided this dataset to you so you don’t have to load it yourself from NLTK.
Besides data, we are also providing code for evaluating your language models and POS tagger, and a skeleton code for the assignment. In this assignment you should not create any new code files, but rather just fill the functions in the skeleton code.
We have provided the following files:
data/Brown_train.txt Untagged Brown training data data/Brown_tagged_train.txt Tagged Brown training data data/Brown_dev.txt Untagged Brown development data data/Brown_tagged_dev.txt Tagged Brown development data data/Sample1.txt Additional sentences for part A data/Sample2.txt More additional sentences for part A perplexity.py A script to analyze perplexity for part A
pos.py A script to analyze POS tagging accuracy for part B
solutionsA.py Skeleton code for part A
solutionsB.py Skeleton code for part B
The only files that you should modify throughout the whole assignment are solutionsA.py and
solutionsB.py.
Data Files Format
The untagged data files have one sentence per line, and the tokens are separated by spaces. The tagged data files are in the same format, except that instead of tokens separated by spaces those files have TOKEN/TAG separated by spaces.
Report
Before starting the assignment, create a “README.txt” file on the homework folder. At the top, include a header that contains your uniqname and name. Throughout the assignment, you will be asked to include specific output or comment on specific aspects of your work. We recommend filling the README file as you go through the assignment, as opposed to starting the report afterwards.
In this report it is not necessary to include introductions and/or explanations, other than the ones
explicitly requested throughout the assignment.
Assignment Part A – Language Model
In this part of the assignment you will be filling the solutionsA.py file. Open the file and notice there are several functions with a #TODO comment; you will have to complete those functions. To understand the general workflow of the script, read the main() function but do not modify it.
1) Calculate the uni-‐, bi-‐, and trigram log-‐probabilities of the data in “Brown_train.txt”. This corresponds to implementing the calc_probabilities() function. In this assignment we will always use log base 2.
Don’t forget to add the appropriate sentence start and end symbols; use “*” as start symbol and “STOP” as end symbol (These are defined as constants START_SYMBOL and STOP_SYMBOL in the skeleton code). You may or may not use NLTK to help you.
The code will output the log probabilities in a file “output/A1.txt”. Here’s a few examples of log
probabilities of uni-‐, bi-‐, and trigrams for you to check your results:
UNIGRAM captain -‐14.2809819899 UNIGRAM captain's -‐17.0883369119 UNIGRAM captaincy -‐19.4102650068
BIGRAM and religion -‐12.9316608989 BIGRAM and religious -‐11.3466983981 BIGRAM and religiously -‐13.9316608989
TRIGRAM and not a -‐4.02974734339
TRIGRAM and not by -‐4.61470984412 TRIGRAM and not come -‐5.61470984412
Make sure your result is exactly the same as the examples above. If it is, include in your README
the log probabilities of the following n-‐grams (note the n-‐grams are case-‐sensitive):
UNIGRAM natural BIGRAM natural that TRIGRAM natural that he
2) Use your models to find the log-‐probability, or score, of each sentence in the Brown training data
with each n-‐gram model. This corresponds to implementing the score() function.
Make sure to accommodate the possibility that you may encounter in the sentences an n-‐gram that doesn’t exist in the training corpus. This will not happen now, because we are computing the log-‐probabilities of the training sentences, but will be necessary for question 5. The rule we are going to use is: if you find any n-‐gram that was not in the training sentences, set the whole sentence log-‐probability to -‐1000 (Use constant MINUS_INFINITY_SENTENCE_LOG_PROB).
The code will output scores in three files: “output/A2.uni.txt”, “output/A2.bi.txt”, “output/A2.tri.txt”. These files simply list the log-‐probabilities of each sentence for each different model. Here’s what the first few lines of each file looks like:
A2.uni.txt
-‐178.726835483
-‐259.85864432
-‐143.33042989
A2.bi.txt
-‐92.1039984276
-‐132.096626407
-‐90.185910842
A2.tri.txt
-‐26.1800453413
-‐59.8531008074
-‐42.839244895
Now, you need to run our perplexity script, “perplexity.py” on each of these files. This script will count the words of the corpus and use the log-‐probabilities computed by you to calculate the total perplexity of the corpus. To run the script, the command is:
python perplexity.py <file of scores <file of sentences that were scored
Where <file of scores is one of the A2 output files and <file of sentences that were scored is “data/Brown_train.txt”. Include the perplexity of the corpus for the three different models in
your README. Here’s what our script printed when <file was “A2.uni.txt”.
python perplexity.py output/A2.uni.txt data/Brown_train.txt
The perplexity is 1052.4865859
3) As a final step in the development of your n-‐gram language model, implement linear interpolation among the three n-‐gram models you have created. This corresponds to implementing the linearscore() function.
Linear interpolation is a method that aims to derive a better tagger by using all three uni-‐, bi-‐, and trigram taggers at once. Each tagger is given a weight described by a parameter lambda. There are some excellent methods for approximating the best set of lambdas, but for now, set all three lambdas to be equal. You can read more about linear interpolation in section 4.4.3 of the book.
The code outputs scores to “output/A3.txt”. The first few lines of this file look like:
-‐46.6216736724
-‐85.799449324
-‐58.5689202358
-‐47.5324350611
-‐52.7601723486
Run the perplexity script on the output file and include the perplexity in your README.
4) Briefly answer on your README the following question: When you compare the performance (perplexity) between the best model without interpolation and the models with linear interpolation, is the result you got expected? Explain why. (max 60 words, but 30 is fine too!)
5) Both “data/Sample1.txt” and “data/Sample2.txt” contain sets of sentences; one of the files is an excerpt of the Brown training dataset. Use your model to score the sentences in both files. Our code outputs the scores of each into “Sample1_scored.txt” and “Sample2_scored.txt”. Run the perplexity script on both output files and include the perplexity output of both samples in your README. Use these results to make an argument for which sample belongs to the Brown dataset and which does not.
Assignment Part B – Part-of-Speech Tagging
In this part of the assignment you will be filling the solutionsB.py file. Open the file and notice there are several functions with a #TODO comment; you will have to complete those functions. To understand the general workflow of the script read the main() function, but do not modify it.
1) First, you must separate the tags and words in “Brown_tagged_train.txt”. This corresponds to implementing the split_wordtags() function. You’ll want to store the sentences without tags in one data structure, and the tags alone in another (see instructions in the code). Make sure to
add sentence start and stop symbols to both lists (of words and tags), and use the constants START_SYMBOL and STOP_SYMBOL already provided. You don’t need to write anything on README about this question.
Hint: make sure you accommodate words that themselves contain backslashes – i.e. “1/2” is encoded as “1/2/NUM” in tagged form; make sure that the token you extract is “1/2” and not “1”.
2) Now, calculate the trigram probabilities for the tags. This corresponds to implementing the calc_trigrams() function. The code outputs your results to a file “output/B2.txt”. Here are a few lines (not contiguous) of this file for you to check your work:
TRIGRAM * * ADJ -‐5.20557515082 TRIGRAM ADJ . X -‐9.99612036303
TRIGRAM NOUN DET NOUN -‐1.26452710647 TRIGRAM X . STOP -‐1.92922692559
After you checked your algorithm is giving the correct output, add to your README the log
probabilities of the following trigrams:
TRIGRAM CONJ ADV ADP TRIGRAM DET NOUN NUM TRIGRAM NOUN PRT PRON
3) The next step is to implement a smoothing method. To prepare for adding smoothing, replace every word that occurs five times or fewer with the token “_RARE_” (use constant RARE_SYMBOL). This corresponds to implementing the calc_known() and replace_rare() functions.
First you will create a list of words that occur more than five times in the training data; when tagging, any word that does not appear in this list should be replaced with the token “_RARE_”. You don’t need to write anything on README about this question. The code outputs the new version of the training data to “output/B3.txt”. Here are the first two lines of this file:
At that time highway engineers traveled rough and dirty roads to accomplish their duties .
_RARE_ _RARE_ vehicles was a personal _RARE_ for such employees , and the matter of
providing state transportation was felt perfectly _RARE_ .
4) Next, we will calculate the emission probabilities on the modified dataset. This corresponds to implementing the calc_emission() function. Here are a few lines (not contiguous) of this file for you to check your work:
America NOUN -‐10.99925955 Columbia NOUN -‐13.5599745045 New ADJ -‐8.18848005226
York NOUN -‐10.711977598
After you checked your algorithm is giving the correct output, add to your README the log
probabilities of the following emissions (note words are case-‐sensitive):
* *
Night NOUN Place VERB prime ADJ STOP STOP
_RARE_ VERB
5) Now, implement the Viterbi algorithm for HMM taggers. The Viterbi algorithm is a dynamic programming algorithm that has many applications. For our purposes, the Viterbi algorithm is a comparatively efficient method for finding the highest scoring tag sequence for a given sentence. Please read about the specifics about this algorithm in sections 8.4 and 9.4 in of the book.
Note: your book uses the term “state observation likelihood” for “emission probability” and the
term “transition probability” for “trigram probability.”
Using your emission and trigram probabilities, calculate the most likely tag sequence for each sentence in “Brown_dev.txt”. This corresponds to implementing the viterbi() function. Your tagged sentences will be output to “B5.txt”. Here is how the first two tagged sentences should look:
He/PRON had/VERB obtained/VERB and/CONJ provisioned/VERB a/DET veteran/ADJ ship/NOUN called/VERB the/DET Discovery/NOUN and/CONJ had/VERB recruited/VERB a/DET crew/NOUN of/ADP twenty-‐one/NOUN ,/. the/DET largest/ADJ he/PRON had/VERB ever/ADV commanded/VERB ./.
The/DET purpose/NOUN of/ADP this/DET fourth/ADJ voyage/NOUN was/VERB clear/ADJ ./.
Note that the output doesn’t have the “_RARE_” token, but you still have to count unknown
words as a “_RARE_” symbol to compute probabilities inside the Viterbi Algorithm.
When exploring the space of possibilities for the tags of a given word, make sure to only consider tags with emission probability greater than zero for that given word. Also, when accessing the transition probabilities of tag trigrams, use -‐1000 (constant LOG_PROB_OF_ZERO in the code) to represent the log-‐probability of an unseen transition.
Once you run your implementation, use the part of speech evaluation script pos.py to compare the output file with “Brown_tagged_dev.txt”. Include the accuracy of your tagger in the README file. To use the script, run the following command:
python pos.py output/B5.txt data/Brown_tagged_dev.txt
This is the result we got with our implementation of the Viterbi algorithm:
Percent correct tags: 93.3249946254
6) Finally, create an instance of NLTK’s trigram tagger set to back off to NLTK’s bigram tagger. Let
the bigram tagger itself back off to NLTK’s default tagger using the tag “NOUN”. Implement this
in the nltk_tagger() function. The code outputs your results to a file “B6.txt”, and this is how the
first two lines of this file should look:
He/NOUN had/VERB obtained/VERB and/CONJ provisioned/NOUN a/DET veteran/NOUN ship/NOUN called/VERB the/DET Discovery/NOUN and/CONJ had/VERB recruited/NOUN a/DET crew/NOUN of/ADP twenty-‐one/NUM ,/. the/DET largest/ADJ he/PRON had/VERB ever/ADV commanded/VERB ./.
The/NOUN purpose/NOUN of/ADP this/DET fourth/ADJ voyage/NOUN was/VERB clear/ADJ ./.
Use pos.py to evaluate the NLTK’s tagger accuracy and put the result in your README. This is the
accuracy that we got with our implementation:
Percent correct tags: 87.9985146677
Submission
Before submission, run your code one more time and record in your README file the time it took to
execute Part A and Part B, separately. Add the times of execution in the end of your README file.
You should submit your assignment through your hidden directory on the Rod server. Once you are done with the homework and have finalized the README.txt file, check once again that this is the path for your homework:
~/hidden/<YOUR_PIN/Homework1/
As a final step, run a script that will set up the permissions to your homework files, so we can access and
run your code to grade it:
~595/hw1_set_permissions.sh <YOUR_PIN
Make sure the command above runs without errors, and do not make any changes or run the code again. If you do run the code again or make any changes, you need to run the permissions script again. Submissions without the correct permissions may incur some grading penalty.
