Journofile: A Personality Profiler of NYTimes Journalists

Samara Bliss
Joseph Lee
and
Posted on Nov 17, 2015

Contributed by Samara Bliss and Joseph Lee. They took NYC Data Science Academy 12 week full time Data Science Bootcamp program between Sept 23 to Dec 18, 2015. The post was based on their third class project(due at 6th week of the program).

Note: You'll find snippets of our code in the following post. For the full code please go to the github repository.

Introduction

Thanks to digital journalism, we have millions of opinions on practically every topic easily accessible at our fingertips. This revolutionary change in how we consume (and contribute to) news forces us to become critical thinkers, capable of evaluating the credibility of countless sources. But how can a reader efficiently evaluate an author's background, style, themes, biases, quirks, etc. without reading his/her entire collective works and biography? Enter Journofile--our solution to this problem. Journofile is a tool written in Python programming language that grabs the New York Times articles written by any inputted author and, using Natural Language Processing, analyzes the texts for most frequently used words, sentiment polarity, sentiment subjectivity, and, most importantly, personality.

Process

To begin, the articles from any given author are grabbed from the NYTimes using the openly accessible article search API. These queries return the URLs to the articles.

We then used the a combination of Python libraries Beautiful Soup and Goose Extractor to simultaneously scrape and parse the article contents. Beautiful soup was used primarily for exploring the tag structure of the HTML page, while Goose was the main packaged used for scraping. Below is a brief snippet of the Goose functions developed for this program. The extractWrapper function calls on the three previous functions to extract the URL text, the list of URLs, and the data of each text.

def extractArticle(url):
g = Goose()
article = g.extract(url=url)
return article.cleaned_text

def extractArticleList(datum):
archive = []
for ii in datum:
archive.append(extractArticle(ii))
return archive

def extractDate(lst):
dates = []
for ii in lst:
match = re.search(r'\d{4}-\d{2}-\d{2}',str(ii))
dates.append(str(match.group(0)))
return dates

def extractWrapper(name, number):
x=CollectPostHistory(name,number)
tmp = extractArticleList(x[0])
dates = extractDate(x[1])
raw = " ".join(tmp)
content = raw.encode('ascii', 'ignore')
return dates, tmp, content

Using the Natural Language Toolkit, we created a wrapper function that tokenizes and tags parts-of-speech to clean text, filters by tags so as to exclude conjunctives, prepositions, determiners, etc., and then casts the filtered text into a data frame that has been sorted by word frequency.


def castFreqDF(cleantext):

tokenized = word_tokenize(cleantext)
tags = nltk.pos_tag(tokenized)

def filteredtags(tags):
wantedTags = ["FW", "JJ", "JJR", "JJS", "NN", "NNP", "NNPS", "NNS"]
ftags = []
tagtag = []
for t in tags:
if t[1] in wantedTags:
ftags.append(t[0])
tagtag.append(t[1])
return ftags , tagtag

x = filteredtags(tags)
fdist = FreqDist(x[0])
taglist = x[1]
vocab1 = fdist.keys()
tmp1 = []
tmp2 = []

for ii in fdist:
tmp1.append(ii)
for jj in fdist:
tmp2.append(fdist[jj])

s1 = pd.Series(tmp1)
s2 = pd.Series(tmp2)

d = {"Word":s1,
"Count" : s2}
df = pd.DataFrame(d)
return df.sort(["Count"], ascending = False, axis = 0)

In order to demonstrate our code, we'll use NYTimes Opinion author, David Brooks. We'll use his name as our passed argument.

author = "David Brooks"
x = extractWrapper(author, 20)

The Seaborn package was used for most of our visualizations.

WordFreq

In order to get the sentiment polarity and sentiment subjectivity of each text we used a library called TextBlob. The polarity is on a scale of -1 to 1 and the subjectivity is on a scale of 0 to 1.

def sentimentpolarity(sentiment_list):

tri_list = sentiment_list
dates = tri_list[0]
articles = tri_list[1]
sample = []
polarity = []
subjectivity = []
tmp_dates = []

for ii in articles:
sample.append(ii
for jj in articles:
blob = TextBlob(jj)
polarity.append(blob.sentiment.polarity)
for kk in articles:
blob2 = TextBlob(kk)
subjectivity.append(blob2.sentiment.subjectivity)

for kk in range(len(articles)):
tmp_dates.append(dates[kk])

c1 = pd.Series(sample)
c2 = pd.Series(polarity)
c3 = pd.Series(subjectivity)
c4 = pd.Series(tmp_dates)

d = {"Sample":c1,
"Polarity":c2,
"Subjectivity":c3,
"Date":c4}
df = pd.DataFrame(d)

return df.sort('Date')

polarity
subjectivity

Lastly, in order to create an in-depth personality assessment of the author, we used a service powered by IBM Watson, the cognitive computing machine that famously won Jeopardy against Ken Jennings in 2011. The API is called Personality Insights and it uses the Linguistic Inquiry and Word Count (LIWC) program which compares the inputted text to internal dictionaries with psychologically-relevant tagging and percentages for each of its personality categories. The personality categories are based on needs, values, and the Big Five personality traits. To read more about the API take a look at this and to read more about LIWC try this. The API exists on the IBM cloud developer platform, Bluemix. We made a post request to the Personality Insights API, inputted the entire corpus of an author’s work, and the API returns the personality analysis as a JSON file. We then parsed the JSON output into a readable pandas data frame containing personality traits and corresponding percentages.


url = "https://gateway.watsonplatform.net/personality-insights/api"
username = "Your username"
password = "Your password

response = requests.post(url + "/v2/profile",
auth=(username, password),
headers = {"content-type": "text/plain"},
data=text)

x = json.loads(response.text)
y = x["tree"]["children"]
trait = []
percentage = []
for ii in y:
for jj in ii["children"]:
for kk in jj["children"]:
#print kk["name"]
trait.append(kk["name"])
#print kk["percentage"]
percentage.append(kk["percentage"])
if "children" in kk:
for zz in kk["children"]:
#print zz["id"]
trait.append(zz["id"])
#print zz["percentage"]
percentage.append(zz["percentage"])
else:
print " "

To visualize the personality assessment we used Bokeh, a new package designed by Continuum Analytics.

conscientiousness
opness
agreeableness
extraversion
emotional

needs

values

Again, please find our full code on our github.

About Authors

Samara Bliss

Samara Bliss

I'm an ex-medical school student turned data scientist, with an interest in health IT, health data analytics, hospital workflow/administration, digital/mobile health technology, and personalized medicine, as well as machine learning, natural language processing, cognitive computing, and deep learning.
View all posts by Samara Bliss >
Joseph Lee

Joseph Lee

A recent graduate from Northwestern University with a B.S. in Biomedical Engineering and a Minor in computer science, Joseph has a strong background in computer engineering and programming concepts. His previous work and academic studies contains a panoply...
View all posts by Joseph Lee >

Related Articles

Leave a Comment

No comments found.

View Posts by Categories


Our Recent Popular Posts


View Posts by Tags

#python #trainwithnycdsa 2019 airbnb Alex Baransky alumni Alumni Interview Alumni Reviews Alumni Spotlight alumni story Alumnus API Application artist aws beautiful soup Best Bootcamp Best Data Science 2019 Best Data Science Bootcamp Best Data Science Bootcamp 2020 Best Ranked Big Data Book Launch Book-Signing bootcamp Bootcamp Alumni Bootcamp Prep Bundles California Cancer Research capstone Career Career Day citibike clustering Coding Course Demo Course Report D3.js data Data Analyst data science Data Science Academy Data Science Bootcamp Data science jobs Data Science Reviews Data Scientist Data Scientist Jobs data visualization Deep Learning Demo Day Discount dplyr employer networking feature engineering Finance Financial Data Science Flask gbm Get Hired ggplot2 googleVis Hadoop higgs boson Hiring hiring partner events Hiring Partners Industry Experts Instructor Blog Instructor Interview Job Job Placement Jobs Jon Krohn JP Morgan Chase Kaggle Kickstarter lasso regression Lead Data Scienctist Lead Data Scientist leaflet linear regression Logistic Regression machine learning Maps matplotlib Medical Research Meet the team meetup Networking neural network Neural networks New Courses nlp NYC NYC Data Science nyc data science academy NYC Open Data NYCDSA NYCDSA Alumni Online Online Bootcamp Online Training Open Data painter pandas Part-time Portfolio Development prediction Prework Programming PwC python python machine learning python scrapy python web scraping python webscraping Python Workshop R R language R Programming R Shiny r studio R Visualization R Workshop R-bloggers random forest Ranking recommendation recommendation system regression Remote remote data science bootcamp Scrapy scrapy visualization seaborn Selenium sentiment analysis Shiny Shiny Dashboard Spark Special Special Summer Sports statistics streaming Student Interview Student Showcase SVM Switchup Tableau team TensorFlow Testimonial tf-idf Top Data Science Bootcamp twitter visualization web scraping Weekend Course What to expect word cloud word2vec XGBoost yelp