Here’s one way to teach an introductory class to NLP
By: Nathan Torento
Tags: Nltk, NLP, Introduction To Nlp, Pipeline, Sentiment Analysis

[0:00-0:05] Learning Goals

I begin class by explaining the Learning Goals below.

- Be able to build an NLP pipeline

- Gain experience and familiarity with NLTK package

Before we go into the actual content of class, let’s explain the rationale behind my most important decisions.

Why build a pipeline?

Natural Language Processing is a field of Data Science that details the theories and methods programmers use to gather, process, and present information about spoken and written text, i.e. natural language. Like all data science related tasks in the real world, programmers will often be tasked to “make sense of this data”. In NLP, this implies that they will have to collect, process, and present some text, often, all by themselves.

For those with some experience in the field, this is no simple task — or at least, will take some time. If you are skeptical on how I managed to fit a seemingly gargantuan task into 1.5 hours, much like my Professor originally was, read and find out how below.

Why Sentiment Analysis?

For my work-study, I had to analyze the theses of my peers. I noticed that a majority of the topics involved sentiment analysis. Apart from that, I found a way to implement it simply (in a few lines of code) and it’s a skill with several benefits.

Why the NLTK library?

The NLTK library is the introductory library for Python users diving into NLP. It contains crucial functions for any and all things NLP-related from the pre-processing to the analysis stage, multiple *corpora for training or testing, it is constantly updated, and in-depth documentation.

*corpus (plural corpora): a collection of written or spoken text made to be electronically accessible for educational or practical purposes;

Why Rotten Tomatoes reviews?

Movie reviews from Rotten Tomatoes are the most popular and most accessible binary reviews out there today — it’s real, accessible text that can be classified into “positive” or “negative”. Furthermore, no complicated code or API’s are required to collect the information.

[0:05–0:11] Pre-class work (PCW) and Prep assessment poll.

I give the class a few minutes to quickly submit the link to their code for pre-class work (described below), and then later, ask them to answer the prep assessment poll (also described below).

Pre-class work

Search for your favorite movie on Rotten Tomatoes. Manually copy down 10 critic reviews: 5 “fresh” (good) reviews and 5 “rotten” (bad) reviews. Separate each by a new line. Save it in a non-formatted ‘review.txt’ file which you can easily open and access later. In less than 100 lines, perform a sentiment analysis. Be sure to include three functions or code chunks. Be sure to effectively use the nltk package to cut the number of code you’ll need to manually create. 1. clean(reviews) #make sure to transform text into lowercase, remove numbers, remove stop words, remove punctuation; 2. lemmatize(text) #hint: from nltk.stem import WordNetLemmatizer, PorterStemmer 3. sentiment analysis #train a model based on built-in nltk movie_reviews to categorize each of your selected reviews as either ‘positive’ or ‘negative’ Have a final output to identify the accuracy of your model (out of 10) in successfully classifying your selected reviews.

Prep assessment poll

Identify the pre-processing steps you took for PCW and explain their importance to your larger goal of sentiment analysis.

Yes, quite a bit of expectation falls on the students to learn this new package and learn how to put it into practice for an “intro” class. Alas, tis the standard of computer science classes at Minerva. Trust, however, that this effort is put into good use for the following activities.

[0:11–0:36] Activity 1: Discuss PCW into breakout groups.

Compare and contrast how everyone in the breakout group implemented pre-class work, particularly with how they trained the model. Note differences that affected runtime, amount of code, and final accuracy.

[0:26–0:41] Debrief Activity 2: Share insights

Everyone share at least one insight they gained from the discussion. What were some practical challenges you ran into? How did someone else overcome those challenges?

This is a crucial time for people to debug code and exchange ideas on implementation such as which packages to use. Given that part of the limitation for the PCW was to minimize the maximum lines of code, this is an introductory session, and this is a “Practical Data Science” class, the easiest implementation is most beneficial to participants in real life and for the upcoming activities later.

[0:41–1:01] Activity 2: Work on separate parts of an example NLP pipeline

Combining all your reviews, create a NLP pipeline of article reviews with sentiment analysis as the end goal. Make sure to label each review for easy accuracy testing later! Input: combined reviews Output: accuracy score The pipeline, in working Python code, should be able to:

- combine everyone’s movie review text files into one (by code or manually)

- pre-process text, with well-commented cleaning elements of your choice

- lemmatize the text

- train a sentiment analysis model on some data (any justifiable classification algorithm trained on the nnltk.movie_reviews or on a k-fold cross-validation of your combined data)

- output a final accuracy score Instructions: One person will probably have to work on their computer and share their screen. Number of breakout groups: 3

An outline of the NLP Pipeline

For this activity, I split the class into three groups. Remember that the ultimate goal of class was to create a functioning NLP pipeline. Each group is responsible for a section of the pipeline. For the activity, they are tasked with reading a python notebook with pre-filled code and specific instructions to test their practical knowledge. If they ran out of time or were stuck, they were free to call on their instructor (me) for help, or view the answer key if they really needed to. See the notebooks below.

[1:01–1:21] Debrief Activity 2: Synthesize the code and run the pipeline

Paste each group's code into the pipeline and run the pipeline.

Activity 2 Debrief: Paste in your code and the pipeline should work!

We then first spent a few minutes copy pasting every group’s code into the respect blocks. Should the code not work, I have backup code at the bottom that’s already run and completed, to show the class how the pipeline should look like and what it would output had it worked.

Crucial pre-filled code for Group 3

Important Note: Because the model training section of Group 2 is dependent on the pre-process section of Group 1 being complete, I’ve pre-filled Group 2 and Group 3's notebook.

We then had a discussion with the prompt below.

What were some technical challenges of working on this task as a group? What were some practical challenges of working on this task as a group?

Obviously, my specific implementation did not necessarily choose an objective “easiest” or “quickest” method.

[1:21–1:30] Reflection Poll

What technical skills or experience were you lacking that hindered your ability to finish PCW and Activity 2? How could they have made the tasks easier?

So, class went well. This is some of the positive feedback I received from my peers.

they now have practical experience of how to perform a sentiment analysis; in fact, my notebooks now serve as code they can use for future reference

although the pre-class required quite a bit of work, they felt that their effort really paid off because they were forced to directly apply their learnings in the activities

having the pre-class work, activity 1, and activity 2 build off each other ensured that the class was engaging and flowed naturally

Points of improvement for the future:

implement text scraping of website — it’s often too much work to manually copy and text from their original sources, so programmers scrape… but let’s leave the diverse and nuanced topic of scraping for another class

implement the input such that they are labelled, perhaps as a 2 column .csv file — referring to Kaggle, this is usually how text for sentiment analysis is pre-formatted

make sure that cells are pre-run, so that in the case that the example code doesn’t run during class, the class can clearly see what was supposed to happen (I forgot to run the final output code for the entire pipeline)

I hope you all enjoyed and found this information useful! As much as it provided me a much needed ego and mood boost to get such positive and constructive feedback, I felt very fulfilled knowing I taught actually useful skills and actually relevant and useful output.