For approach to analysis see the tidytext book.

Setup

In case the tidyverse is not installed on your computer already (you haven’t used it in R before) you need to install it before loading the library. This you need to do only once as long as you use the same computer or don’t need to update a loaded package. The library() function needs to be used whenever you start from a clean R state.

install.packages("tidyverse")

library(tidyverse)

Ditto for the tidytext package:

install.packages("tidytext")

library(tidytext)

Special purpose packages:

install.packages("wordcloud")

install.packages("igraph")

trying URL 'https://cran.rstudio.com/bin/macosx/el-capitan/contrib/3.5/igraph_1.2.2.tgz'
Content type 'application/x-gzip' length 6872298 bytes (6.6 MB)
==================================================
downloaded 6.6 MB


The downloaded binary packages are in
    /var/folders/42/_86yt7ts4w335_0q50tmvsrh0000gp/T//RtmpUxtNQC/downloaded_packages

install.packages("ggraph")

install.packages("widyr")

install.packages("topicmodels")

Data import

We read the data with read_csv, not with the base package read.csv, to create a tibble.

text_df <- read_csv("interviews.csv")

The data come in the format:

Interview: Interview number 1 to 30.
Question: {Q1, Q2, …, Q8}
Speaker: R = Researcher, S01 to S30 = Subjects
Text: A question from R and the answer from Sxx.

Note that this table is in the ‘long’ format, so we need to filter rows rather than select columns to select variables such as questions and speakers.

Change the data structure by adding a column “Follow-up” that is either True or False with respect to the column “Question”

Data cleaning

Clearly there are the typical stop words that we don’t want to have in counts. Let’s remove them. There’s a data frame that has stop words specified for us, as part of tidytext:

data(stop_words)

We can View(stop_words) to see them, and add our own ones, of course. Here are the first 10 stop words:

head(stop_words)

Let’s get to the words:

words_df <- text_df %>%
  unnest_tokens(word, Text)

The key function is unnest_tokens(), which converts text into a column of n-grams (with default value 1, i.e., single words). Since the survey data is in one-word-per-row format, we can remove stop symbols with an anti_join (from dplyr):

words_df <- anti_join(words_df, stop_words)

In general the anti-join command is:

anti_join(a, b, by = "x1")  -- all rows in a that do not have a mach in b (on variable x1)

On inspection, there are still a few words in there which are not really English. Let’s remove these as well.

stop_words2 <- tibble(word = c("uh", "ah", "yeah", "um", "uhm", "don't", "it's"))
words_df <- words_df %>%
  anti_join(stop_words2)

Joining, by = "word"

To fix ‘don’t’ and “it’s” are not caught this way. The problem is that this is unicode, so not a straight “’”. To wit, when we search for the straight apostrophe sign, there’s only one hit, and it’s not one that is problematic:

words_df %>%
  filter(str_detect(word, "'"))

We get more of the real problems by looking for all punctuation characters:

words_df %>%
  filter(str_detect(word, "[:punct:]"))

Let’s remove these:

words_df <- words_df %>%
  filter(!str_detect(word, "[:punct:]"))

The function str_detect() comes from the stringr package, see help.

We may also want to remove numbers and special characters. First we need a tibble to store these kind of stop symbols under:

stop_symbols <- tibble(word = c("1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "#", "(", ")", "."))

words_df <- words_df %>%
  anti_join(stop_symbols)

Word frequencies

A first look at all words:

words_df %>%
  count(word, sort = TRUE)

Let’s do a bit of graphing of words with a frequency GT 10.

words_df %>%
  count(word, sort = TRUE) %>%
  filter(n > 10) %>%
  mutate(word = reorder(word, n)) %>%
  ggplot(aes(word, n)) +
  geom_col() +
  xlab(NULL) +
  coord_flip()

Now we can calculate word frequencies for each person. First, we group by person and count how many times each person used each word. Then we use left_join() to add a column of the total number of words used by each person. Finally, we calculate a frequency for each person and word.

frequency <- words_df %>% 
  group_by(Speaker) %>% 
  count(word, sort = TRUE) %>% 
  left_join(words_df %>% 
              group_by(Speaker) %>% 
              summarise(total = n())) %>%
  mutate(freq = n/total)

Joining, by = "Speaker"

A left_join joins matching rows from b into a: inner_join(a,b, by = "x").

Let’s look at the most frequent words:

head(frequency)

Not surprisingly, they come all from Researcher because he speaks most. For many analysis it will make sense to filter out Researcher’s text:

frequency %>%
  filter(Speaker != "R") %>%
  top_n(2)

Selecting by freq

We will need the data other than the researcher’s questions frequently, so let’s create a variable for the two:

words_students <- words_df %>%
  filter(Speaker != "R")

And a variable for the Researcher words:

words_researcher <- words_df %>%
  filter(Speaker == "R")

Word cloud

library(wordcloud)

Loading required package: RColorBrewer

words_students %>%
  count(word) %>%
  with(wordcloud(word, n, max.words = 100))

Sentiment analysis

Tidytext comes with three lexicons that contains words for sentiments, overall more than 27,000 words:

head(sentiments)

Let’s use the nrc lexicon and look for joyfull words. First, get the joyful words into a df:

nrc_joy <- get_sentiments("nrc") %>% 
  filter(sentiment == "joy")

Then look for them in answers For this, we use inner_join, which retains only the matching rows in both sets. The general syntax is inner_join(a, b, by = "x1"), but in the shorter format this reduces to:

words_students %>%
  inner_join(nrc_joy) %>%
  count(word, sort = TRUE) %>%
  top_n(10)

Joining, by = "word"
Selecting by n

The long form would be inner_join(words_q1, nrc_joy, by = "word") but R is able to figure the arguments provided in the short form.

To do the same analysis for the sentiment ‘fear’, simply replace ‘joy’ with ‘fear’ above (and perhaps rename the variable to nrc_fear or such).

Sentiment anaysis on one question

Just for Q1 and all follow-up questions:

words_students %>%
  filter(Question == "Q1" | Question == "Q1-F") %>%
  inner_join(nrc_joy) %>%
  count(word, sort = TRUE)

Joining, by = "word"

Sentiment on all questions

words_students %>%
  group_by(Question) %>%
  inner_join(nrc_joy) %>%
  count(word, sort = FALSE)

We turned sorting on the count off here because we want to have the results grouped by question id. If Sorting was TRUE, the numeric count would be used first, then the question ID.

Sentiment analysis on a sub-set of all questions

Let’s pick Q1, 3 and 7:

words_students %>%
  filter(Question == "Q1" | Question == "Q3" | Question == "Q7") %>%
  inner_join(nrc_joy) %>%
  count(word, sort = TRUE)

Most common positive and negative sentiment words

Using the lexicon bing, which classifies sentiment words as positive or negative, we can find how words costribute to these overall sentiments:

bing_word_counts <- words_students %>%
  inner_join(get_sentiments("bing")) %>%
  count(word, sentiment, sort = TRUE) %>%
  ungroup()
head(bing_word_counts)

Let’s graph this with ggplot2:

bing_word_counts %>%
  group_by(sentiment) %>%
  top_n(10) %>%
  ungroup() %>%
  mutate(word = reorder(word, n)) %>%
  ggplot(aes(word, n, fill = sentiment)) +
  geom_col(show.legend = FALSE) +
  facet_wrap(~sentiment, scales = "free_y") +
  labs(y = "Contribution to sentiment",
       x = NULL) +
  coord_flip()

Selecting by n

The top_n(10) is returning more than 10 rows if there are ties. Will have to write a more complex expression with filter() and min_rank() because that’s what top_n wraps.

Here’s a cool combination of wordclouds with bing words:

library(reshape2)


Attaching package: ‘reshape2’

The following object is masked from ‘package:tidyr’:

    smiths

We need reshape2 for the acast function. acast is a complex function used to transform between data frames and matrices. comparison.cloud() needs a matrix as input. For more see http://had.co.nz/reshape/.

words_students %>%
  inner_join(get_sentiments("bing")) %>%
  count(word, sentiment, sort = TRUE) %>%
  acast(word ~ sentiment, value.var = "n", fill = 0) %>%
  comparison.cloud(colors = c("gray20", "gray80"),
                   max.words = 100)

Joining, by = "word"

Word and Document Frequency

Calculating term frequency per interview

Whole interview corpus

Step 1: A tibble word count by interview sorted by count. This has length 1097 observations, less than the full corpus (2617 obs) because we aggregate in each interview: count(x, ..., wt = NULL, sort = FALSE) with x the tbl and ... the variables to group by; wt is for weighting by counting number of rows.

interview_words <- words_df %>%
  count(Interview, word, sort = TRUE) %>%
  ungroup()
head(interview_words)

So here we have count(words_df, Interview, word, wt = NULL, sort = TRUE.

Step 2: total of words per interview

total_words <- interview_words %>% 
  group_by(Interview) %>% 
  summarize(total = sum(n))
total_words

Step 3: Add the total count column to each of the words and their individual frequency

interview_words <- left_join(interview_words, total_words, by = "Interview")
head(interview_words)

Left_join(a, b, by = "x1') joins mathing rows from b to a. The “by” is included here for clarity, but could be omitted because it is the single shared variable in both tbls.

Let’s look at the term frequency:

ggplot(interview_words, aes(n/total, fill = Interview)) +
  geom_histogram(show.legend = FALSE) +
  facet_wrap(~Interview, ncol = 2, scales = "free_y")

tf_idf For students reponses only

Since we are looking for differences between interviews (students), it probably makes sense to remove the “shared” factor–the Researcher–and look at students’ answers only:

interview_words <- words_students %>%
  count(Interview, word, sort = TRUE) %>%
  ungroup()
head(interview_words)

The tf_idf value be calcuated based on the table just created like this:

interview_words <- interview_words %>%
  bind_tf_idf(word, Interview, n)
head(interview_words)

Words that are very common across all interviews have a low idf term, and so wil the tf_idf. Let’s find the distinct words by sorting on the tf_idf:

interview_words %>%
  arrange(desc(tf_idf))

We can plot this result:

interview_words %>%
  arrange(desc(tf_idf)) %>%
  mutate(word = factor(word, levels = rev(unique(word)))) %>% 
  group_by(Interview) %>% 
  top_n(10) %>% 
  ungroup %>%
  ggplot(aes(word, tf_idf, fill = Interview)) +
  geom_col(show.legend = FALSE) +
  labs(x = NULL, y = "tf-idf") +
  facet_wrap(~Interview, ncol = 2, scales = "free") +
  coord_flip()

Selecting by tf_idf

Todo: unpack the mutate line

Idea: Doing the analysis by question should yield a more distinct profile of specific words.

Relationship between words - N-grams

Filter out researcher talk and create bi-grams:

student_bigrams <- text_df %>%
  filter(Speaker != "R") %>%
  unnest_tokens(bigram, Text, token = "ngrams", n = 2)
student_bigrams

The way to control the token size is to set paramaters of the unnest_token function, see help(unnest_token"). A single word is an ngram of length 1, so two adjacent words can be used as the token unit by unnest_tokens(ngram, txt, token = "ngrams", n = 2).

We’ll copy these into a more gnerally named variable in case we want to redo this analysis on other bigrams:

bigrams <- student_bigrams

Removing stop words

Many of the bi-grams will be stop word phrases, of which we need to get rid off. The pattern is separate/filter/count/unite:

Step 1: separate into two columns

bigrams_separated <- bigrams %>%
  separate(bigram, c("word1", "word2"), sep = " ")

Step 2: Filter out stopwords

bigrams_filtered <- bigrams_separated %>%
  filter(!word1 %in% stop_words$word) %>%
  filter(!word2 %in% stop_words$word)

Much less pairs! Let’s count them:

Step 3: count

bigram_counts <- bigrams_filtered %>% 
  count(word1, word2, sort = TRUE)

But still lots of non-meaning words, all those ahs and uhs, because this is talk. Let’s filter some more.

bigrams_filtered <- bigrams_filtered %>%
  filter(!word1 %in% stop_words2$word) %>%
  filter(!word2 %in% stop_words2$word)

Step 4: And let’s produce a united version again:

bigrams_united <- bigrams_filtered %>%
  unite(bigram, word1, word2, sep = " ")
head(bigrams_united)

Analysis

Counting because we can:

bigrams_united %>%
  count(bigram, sort = TRUE)

Lets look at all phrases with a specific word in position 2

bigrams_filtered %>%
  filter(word2 == "assignment") %>%
  count(Interview, word1, sort = TRUE)

Improvement: use regex to deal with different forms of the stem:

bigrams_filtered %>%
  filter(grepl("assign", word2)) %>%
  count(Interview, word1, sort = TRUE)

grepl(pattern, x) is the logic form of grep, returnign a vector of match or not for each element of x.

Sentiment analysis with words in context

For sentiment analysis we need in particular into negations""

bigrams_separated %>%
  filter(word1 == "not") %>%
  count(word1, word2, sort = TRUE)

Let’s use that for some analysis with the AFINN lexicon, with uses a numeric score to express sentiment direction:

AFINN <- get_sentiments("afinn")
head(AFINN)

not_words <- bigrams_separated %>%
  filter(word1 == "not") %>%
  inner_join(AFINN, by = c(word2 = "word")) %>%
  count(word2, score, sort = TRUE) %>%
  ungroup()
not_words

(This needs some unpacking) We see how important it is to watch out for negations when it comes to sentiments. Other negation words deserve attention, too:

negation_words <- c("not", "no", "never", "without")
negated_words <- bigrams_separated %>%
  filter(word1 %in% negation_words) %>%
  inner_join(AFINN, by = c(word2 = "word")) %>%
  count(word1, word2, score, sort = TRUE) %>%
  ungroup()
negated_words

This only makes a small difference in the 5 interviews, but with a larger corpus we are bound to see more impact. We can compute and visualise the impact by computing a value score * n:

negated_words %>%
  mutate(contribution = n * score) %>%
  arrange(desc(abs(contribution))) %>%
  head(20) %>%
  mutate(word2 = reorder(word2, contribution)) %>%
  ggplot(aes(word2, n * score, fill = n * score > 0)) +
  geom_col(show.legend = FALSE) +
  xlab("Words preceded by \"not\"") +
  ylab("Sentiment score * number of occurrences") +
  coord_flip()

This also makes it visible that in the first 5 interviews there were no negatve words negated, such as “no doubt”.

Graphing bigram networks

library(igraph)


Attaching package: ‘igraph’

The following objects are masked from ‘package:dplyr’:

    as_data_frame, groups, union

The following objects are masked from ‘package:purrr’:

    compose, simplify

The following object is masked from ‘package:tidyr’:

    crossing

The following object is masked from ‘package:tibble’:

    as_data_frame

The following objects are masked from ‘package:stats’:

    decompose, spectrum

The following object is masked from ‘package:base’:

    union

The dataframe we need for this is bigram_counts with word1, word2 and n as the “weight”. Let’s use only the those with n GEG 2:

bigram_graph <- bigram_counts %>%
  filter(n >= 2) %>%
  graph_from_data_frame()

In `d' `NA' elements were replaced with string "NA"

bigram_graph

IGRAPH bd166e8 DN-- 23 13 -- 
+ attr: name (v/c), n (e/n)
+ edges from bd166e8 (vertex names):
 [1] wrong        ->direction     blah         ->blah          individual   ->contributions share        ->ideas        
 [5] feel         ->happy         individual   ->assignment    inter        ->related       participation->mark         
 [9] pass         ->score         team         ->leader        ten          ->percent       time         ->consuming    
[13] NA           ->NA

For plottigng we use ggraph:

library(ggraph)

set.seed(2017)
ggraph(bigram_graph, layout = "fr") +
  geom_edge_link() +
  geom_node_point() +
  geom_node_text(aes(label = name), vjust = 1, hjust = 1)

Not a particularly connected graph, but the principle is clear.

Correlations among questions

library(widyr)

word_pairs <- words_students %>%
  pairwise_count(word, Question, sort = TRUE)
word_pairs

These are pair counts per question. Here’s the same for interviews:

word_pairs <- words_students %>%
  pairwise_count(word, Interview, sort = TRUE)
word_pairs

Note that these become rather big tables because so many things go togehter on that scale. We can also look this way for specific combinations of words. Let’s go back to pairs within questions, and further reduce to the first interview:

word_pairs <- words_students %>%
  filter(Interview == 1) %>%
  pairwise_count(word, Question, sort = TRUE)
word_pairs

Adn lets look for pairs that have “assignment” in them. Note that the level of counting is the Question. One problem is that we have questions with labels Q and Q-F, which in this analysis get counted separately.

word_pairs %>% filter(item1 == "assignment")

Let’s calculate a correlation between (frequent) words:

word_cors <- words_students %>% group_by(word) %>% filter(n() >= 20) %>% pairwise_cor(word, Question, sort = TRUE) word_cors

Plots help to get an overview:

word_cors %>% filter(item1 %in% c("mark", "time", "idea", "assignment")) %>% group_by(item1) %>% top_n(6) %>% ungroup() %>% mutate(item2 = reorder(item2, correlation)) %>% ggplot(aes(item2, correlation)) + geom_bar(stat = "identity") + facet_wrap(~ item1, scales = "free") + coord_flip()

Selecting by correlation

And based on correlations we can create a network graph:

set.seed(2016) word_cors %>% filter(correlation > .15) %>% graph_from_data_frame() %>% ggraph(layout = "fr") + geom_edge_link(aes(edge_alpha = correlation), show.legend = FALSE) + geom_node_point(color = "lightblue", size = 5) + geom_node_text(aes(label = name), repel = TRUE) + theme_void()

Topic models

In general, TMs classify documents into topics and determine the overlap of a document with a topic. Each topic is made up out of a number of words.

Casting the tidy text df into a document-term matrix

Most text mining packages use DTM format, which is a matrix where:

each row represents one document (such as a book or article),

each column represents one term, and

each value (typically) contains the number of appearances of that term in that document.

Here’s how to turn a tidy text df into a DTM:

library(tm)

students_dtm <- words_students %>% count(Interview, word) %>% cast_dtm(Interview, word, n)

Topics across interviews

With this we have a dtm for each of the 5 interviews, students’ contributions only. Based on this we can mine for topics:

library(topicmodels)

# set a seed so that the output of the model is predictable students_lda <- LDA(students_dtm, k = 2, control = list(seed = 1234)) students_lda

A LDA_VEM topic model with 2 topics.

This object contains a model with just two groups, to make things easier. This model needs to be inspected to gain insights. For instance, we can look at how the words relate to the topics, extracting the beta value from the matrix. We use tidy to turn that column into a tibble topic-term-beta. The betas can be interpreted as probabilities or the term belonging to the topic.

students_topics <- tidy(students_lda, matrix = "beta") students_topics

Let’s look at the top-10 terms:

students_top_terms <- students_topics %>% group_by(topic) %>% top_n(10, beta) %>% ungroup() %>% arrange(topic, -beta)

And visualise them:

students_top_terms %>% mutate(term = reorder(term, beta)) %>% ggplot(aes(term, beta, fill = factor(topic))) + geom_col(show.legend = FALSE) + facet_wrap(~ topic, scales = "free") + coord_flip()

Due to the small corpus, and the fact that we have the same questions in all interviews, this leads not to topics which are easily interpreted. A corresponding analysis, kind of a validation question, would look into topics based on the questions.

The alternative view is to look for terms which differ most between topics.

beta_spread <- students_topics %>% mutate(topic = paste0("topic", topic)) %>% spread(topic, beta) %>% filter(topic1 > .001 | topic2 > .001) %>% mutate(log_ratio = log2(topic2 / topic1)) beta_spread

To do: Plot a graph with the highest (positive and negative) differences in log ratio.

Topics across questions

students_dtm_questions <- words_students %>% count(Question, word) %>% cast_dtm(Question, word, n) students_dtm_questions

We have 16 questions (documents) here because of the follow up questions. Really need to address that in the base model by introducing a column for follow up. In any case, 9 topics should be a good fit to the data.

students_lda_questions <- LDA(students_dtm_questions, k = 9) students_lda_questions

students_topics_questions <- tidy(students_lda_questions, matrix = "beta") students_topics_questions

students_top_terms_questions <- students_topics_questions %>% group_by(topic) %>% top_n(5, beta) %>% ungroup() %>% arrange(topic, -beta)

And visualise them:

students_top_terms_questions %>% mutate(term = reorder(term, beta)) %>% ggplot(aes(term, beta, fill = factor(topic))) + geom_col(show.legend = FALSE) + facet_wrap(~ topic, scales = "free") + coord_flip()

Something like this could be used, with the overall corpus, to see if the nine questions yielded different answers, of if other semantic similarities show up. Question 5, for intance, really should be about facilitation.

Also, by changing k we can explore goodness of fit perhaps, for alternative models.

Miscalleneous

Stemming

This now also is the point were we also could do some stemming. For this we need this library:

library(SnowballC)

Which gives us a function ‘wordstem’:

words_stemmed <- mutate(words_df, word = wordStem(word)) head(words_stemmed, n=20L)

But we don’t want to use the stemmed words just now because it would intefere with the sentiment analysis. Stemming is useful, but only once we no longer need “real” words, such as for topic modelling and the likes.

Appendices

Lessons learned

To make analysis flexible, use a distinct variable name for the data set the analysis is based on, and bind it at the beginning of the analysis to the specific data set, which you expect will be varied.

---
title: "Interview Analysis (5 respondents)"
output: html_notebook
---


For approach to analysis see [the tidytext book](https://www.tidytextmining.com/sentiment.html). 


## Setup

In case the tidyverse is not installed on your computer already (you haven't used it in R before) you need to install it before loading the library. This you need to do only once as long as you use the same computer or don't need to update a loaded package. The `library()` function needs to be used whenever you start from a clean R state. 


```{r}
install.packages("tidyverse")
```

```{r}
library(tidyverse)
```

Ditto for the tidytext package:

```{r}
install.packages("tidytext")
```

```{r}
library(tidytext)
```

Special purpose packages:

```{r}
install.packages("wordcloud")
```

```{r}
install.packages("igraph")
```
```{r}
install.packages("ggraph")
```

```{r}
install.packages("widyr")
```
```{r}
install.packages("topicmodels")
```


## Data import

We read the data with `read_csv`, not with the base package `read.csv`, to create a tibble. 
```{r Reading from file, message=FALSE, warning=FALSE}
text_df <- read_csv("interviews.csv")
```

The data come in the format:

1. Interview: Interview number 1 to 30.
2. Question: {Q1, Q2, ..., Q8}
3. Speaker: R = Researcher, S01 to S30 = Subjects
4. Text: A question from R and the answer from Sxx. 

Note that this table is in the 'long' format, so we need to filter rows rather than select columns to select variables such as questions and speakers. 

> Change the data structure by adding a column "Follow-up" that is either True or False with respect to the column "Question"

## Data cleaning

Clearly there are the typical stop words that we don't want to have in counts. Let's remove them. There's a data frame that has stop words specified for us, as part of tidytext: 

```{r stop-words}
data(stop_words)
```
We can `View(stop_words)` to see them, and add our own ones, of course. Here are the first 10 stop words:

```{r}
head(stop_words)
```


Let's get to the words: 

```{r first call to unnest_token()}
words_df <- text_df %>%
  unnest_tokens(word, Text)
```

The key function is unnest_tokens(), which converts text into a column of n-grams (with default value 1, i.e., single words). Since the survey data is in one-word-per-row format, we can remove stop symbols with an anti_join (from dplyr):

```{r echo=TRUE, message=FALSE, warning=FALSE}
words_df <- anti_join(words_df, stop_words)
```

In general the anti-join command is:
```
anti_join(a, b, by = "x1")  -- all rows in a that do not have a mach in b (on variable x1)
```
On inspection, there are still a few words in there which are not really English. Let's remove these as well. 

```{r}
stop_words2 <- tibble(word = c("uh", "ah", "yeah", "um", "uhm", "don't", "it's"))
words_df <- words_df %>%
  anti_join(stop_words2)
```
**To fix** 'don't' and "it's" are not caught this way. The problem is that this is unicode, so not a straight "'". To wit, when we search for the straight apostrophe sign, there's only one hit, and it's not one that is problematic: 

```{r}
words_df %>%
  filter(str_detect(word, "'"))
```

We get more of the real problems by looking for all punctuation characters:

```{r}
words_df %>%
  filter(str_detect(word, "[:punct:]"))
```

Let's remove these: 

```{r}
words_df <- words_df %>%
  filter(!str_detect(word, "[:punct:]"))
```

The function `str_detect()` comes from the stringr package, see help. 

We may also want to remove numbers and special characters. First we need a tibble to store these kind of stop symbols under:

```{r}
stop_symbols <- tibble(word = c("1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "#", "(", ")", "."))
```


```{r message=FALSE, warning=FALSE}
words_df <- words_df %>%
  anti_join(stop_symbols)
```

## Word frequencies

A first look at all words: 
```{r}
words_df %>%
  count(word, sort = TRUE)
```



Let's do a bit of graphing of words with a frequency GT 10. 

```{r}
words_df %>%
  count(word, sort = TRUE) %>%
  filter(n > 10) %>%
  mutate(word = reorder(word, n)) %>%
  ggplot(aes(word, n)) +
  geom_col() +
  xlab(NULL) +
  coord_flip()
```


Now we can calculate word frequencies for each person. First, we group by person and count how many times each person used each word. Then we use left_join() to add a column of the total number of words used by each person. Finally, we calculate a frequency for each person and word.

```{r Frequency per respondent}
frequency <- words_df %>% 
  group_by(Speaker) %>% 
  count(word, sort = TRUE) %>% 
  left_join(words_df %>% 
              group_by(Speaker) %>% 
              summarise(total = n())) %>%
  mutate(freq = n/total)
```
A left_join joins matching rows from b into a: `inner_join(a,b, by = "x")`. 

Let's look at the most frequent words:

```{r}
head(frequency)
```
Not surprisingly, they come all from Researcher because he speaks most. For many analysis it will make sense to filter out Researcher's text:

```{r}
frequency %>%
  filter(Speaker != "R") %>%
  top_n(2)
```

We will need the data other than the researcher's questions frequently, so let's create a variable for the two:

```{r}
words_students <- words_df %>%
  filter(Speaker != "R")
```
And a variable for the Researcher words:

```{r}
words_researcher <- words_df %>%
  filter(Speaker == "R")
```

### Word cloud


```{r}
library(wordcloud)
```
```{r}
words_students %>%
  count(word) %>%
  with(wordcloud(word, n, max.words = 100))
```


## Sentiment analysis 

Tidytext comes with three lexicons that contains words for sentiments, overall more than 27,000 words:


head(sentiments)

Let's use the nrc lexicon and look for joyfull words. First, get the joyful words into a df:


```{r}
nrc_joy <- get_sentiments("nrc") %>% 
  filter(sentiment == "joy")
```

Then look for them in answers For this, we use inner_join, which retains only the matching rows in both sets. The general syntax is `inner_join(a, b, by = "x1")`, but in the shorter format this reduces to:

```{r}
words_students %>%
  inner_join(nrc_joy) %>%
  count(word, sort = TRUE) %>%
  top_n(10)
```

The long form would be `inner_join(words_q1, nrc_joy, by = "word")`
but R is able to figure the  arguments provided in the short form.

To do the same analysis for the sentiment 'fear', simply replace 'joy' with 'fear' above (and perhaps rename the variable to nrc_fear or such). 


### Sentiment anaysis on one question

Just for Q1 and all follow-up questions:

```{r}
words_students %>%
  filter(Question == "Q1" | Question == "Q1-F") %>%
  inner_join(nrc_joy) %>%
  count(word, sort = TRUE)
```


### Sentiment on all questions

```{r}
words_students %>%
  group_by(Question) %>%
  inner_join(nrc_joy) %>%
  count(word, sort = FALSE)
```
We turned sorting on the count off here because we want to have the results grouped by question id. If Sorting was TRUE, the numeric count would be used first, then the question ID. 

### Sentiment analysis on a sub-set of all questions

Let's pick Q1, 3 and 7: 

```{r}
words_students %>%
  filter(Question == "Q1" | Question == "Q3" | Question == "Q7") %>%
  inner_join(nrc_joy) %>%
  count(word, sort = TRUE)
```


### Most common positive and negative sentiment words

Using the lexicon bing, which classifies sentiment words as positive or negative, we can find how words costribute to these overall sentiments:

```{r}
bing_word_counts <- words_students %>%
  inner_join(get_sentiments("bing")) %>%
  count(word, sentiment, sort = TRUE) %>%
  ungroup()
head(bing_word_counts)
```
Let's graph this with ggplot2: 

```{r}
bing_word_counts %>%
  group_by(sentiment) %>%
  top_n(10) %>%
  ungroup() %>%
  mutate(word = reorder(word, n)) %>%
  ggplot(aes(word, n, fill = sentiment)) +
  geom_col(show.legend = FALSE) +
  facet_wrap(~sentiment, scales = "free_y") +
  labs(y = "Contribution to sentiment",
       x = NULL) +
  coord_flip()
```
The top_n(10) is returning more than 10 rows if there are ties. Will have to write a more complex expression with filter() and min_rank() because that's what top_n wraps. 


Here's a cool combination of wordclouds with bing words:

```{r}
library(reshape2)
```
We need reshape2 for the `acast` function. `acast` is a complex function used to transform between data frames and matrices. `comparison.cloud()` needs a matrix as input. For more see http://had.co.nz/reshape/. 

```{r}
words_students %>%
  inner_join(get_sentiments("bing")) %>%
  count(word, sentiment, sort = TRUE) %>%
  acast(word ~ sentiment, value.var = "n", fill = 0) %>%
  comparison.cloud(colors = c("gray20", "gray80"),
                   max.words = 100)
```

# Word and Document Frequency

## Calculating term frequency per interview

### Whole interview corpus

Step 1: A tibble word count by interview sorted by count. This has length 1097 observations, less than the full corpus (2617 obs) because we aggregate in each interview: 
`count(x, ..., wt = NULL, sort = FALSE)` with x the tbl and `...` the variables to group by; wt is for weighting by counting number of rows. 

```{r}
interview_words <- words_df %>%
  count(Interview, word, sort = TRUE) %>%
  ungroup()

head(interview_words)
```
So here we have `count(words_df, Interview, word, wt = NULL, sort = TRUE`. 


Step 2: total of words per interview 
```{r}
total_words <- interview_words %>% 
  group_by(Interview) %>% 
  summarize(total = sum(n))

total_words
```

Step 3: Add the total count column to each of the words and their individual frequency

```{r}
interview_words <- left_join(interview_words, total_words, by = "Interview")
head(interview_words)
```
`Left_join(a, b, by = "x1')` joins mathing rows from b to a. The "by" is included here for clarity, but could be omitted because it is the single shared variable in both tbls.

Let's look at the term frequency: 

```{r}
ggplot(interview_words, aes(n/total, fill = Interview)) +
  geom_histogram(show.legend = FALSE) +
  facet_wrap(~Interview, ncol = 2, scales = "free_y")
```

### tf_idf For students reponses only

Since we are looking for differences between interviews (students), it probably makes sense to remove the "shared" factor--the Researcher--and look at students' answers only:

```{r}
interview_words <- words_students %>%
  count(Interview, word, sort = TRUE) %>%
  ungroup()

head(interview_words)
```

The tf_idf value be calcuated based on the table just created like this:

```{r}
interview_words <- interview_words %>%
  bind_tf_idf(word, Interview, n)
head(interview_words)
```
Words that are very common across all interviews have a low idf term, and so wil the tf_idf. Let's find the distinct words by sorting on the tf_idf:

```{r}
interview_words %>%
  arrange(desc(tf_idf))
```

We can plot this result:

```{r}
interview_words %>%
  arrange(desc(tf_idf)) %>%
  mutate(word = factor(word, levels = rev(unique(word)))) %>% 
  group_by(Interview) %>% 
  top_n(10) %>% 
  ungroup %>%
  ggplot(aes(word, tf_idf, fill = Interview)) +
  geom_col(show.legend = FALSE) +
  labs(x = NULL, y = "tf-idf") +
  facet_wrap(~Interview, ncol = 2, scales = "free") +
  coord_flip()
```
**Todo:** unpack the mutate line 

> Idea: Doing the analysis by question should yield a more distinct profile of specific words. 

# Relationship between words - N-grams

Filter out researcher talk and create bi-grams:

```{r}
student_bigrams <- text_df %>%
  filter(Speaker != "R") %>%
  unnest_tokens(bigram, Text, token = "ngrams", n = 2)

head(student_bigrams)
```

The way to control the token size is to set paramaters of the unnest_token function, see 
`help(unnest_token")`. A single word is an ngram of length 1, so two adjacent words can be used as the token unit by `unnest_tokens(ngram, txt, token = "ngrams", n = 2)`. 

We'll copy these into a more gnerally named variable in case we want to redo this analysis on other bigrams:

```{r}
bigrams <- student_bigrams
```

### Removing stop words 

Many of the bi-grams will be stop word phrases, of which we need to get rid off. The pattern is separate/filter/count/unite: 

Step 1: separate into two columns


```{r}
bigrams_separated <- bigrams %>%
  separate(bigram, c("word1", "word2"), sep = " ")
```

Step 2: Filter out stopwords 

```{r}
bigrams_filtered <- bigrams_separated %>%
  filter(!word1 %in% stop_words$word) %>%
  filter(!word2 %in% stop_words$word)
```

Much less pairs!  Let's count them:

Step 3: count

```{r}
bigram_counts <- bigrams_filtered %>% 
  count(word1, word2, sort = TRUE)
```

But still lots of non-meaning words, all those ahs and uhs, because this is talk. Let's filter some more. 

```{r}
bigrams_filtered <- bigrams_filtered %>%
  filter(!word1 %in% stop_words2$word) %>%
  filter(!word2 %in% stop_words2$word)
```

Step 4: And let's produce a united version again:


```{r}
bigrams_united <- bigrams_filtered %>%
  unite(bigram, word1, word2, sep = " ")

head(bigrams_united)
```

### Analysis

Counting because we can:
 

```{r}
bigrams_united %>%
  count(bigram, sort = TRUE)
```

 Lets look at all phrases with a specific word in position 2
```{r}
bigrams_filtered %>%
  filter(word2 == "assignment") %>%
  count(Interview, word1, sort = TRUE)
```
 Improvement: use regex to deal with different forms of the stem: 
 
```{r}
bigrams_filtered %>%
  filter(grepl("assign", word2)) %>%
  count(Interview, word1, sort = TRUE)
```

`grepl(pattern, x)` is the logic form of `grep`, returnign a vector of match or not for each element of x. 

### Sentiment analysis with words in context

For sentiment analysis we need in particular into negations""

```{r}
bigrams_separated %>%
  filter(word1 == "not") %>%
  count(word1, word2, sort = TRUE)
```

Let's use that for some analysis with the AFINN lexicon, with uses a numeric score to express sentiment direction: 

```{r}
AFINN <- get_sentiments("afinn")
head(AFINN)
```


```{r}
not_words <- bigrams_separated %>%
  filter(word1 == "not") %>%
  inner_join(AFINN, by = c(word2 = "word")) %>%
  count(word2, score, sort = TRUE) %>%
  ungroup()

not_words
```

(This needs some unpacking)
We see how important it is to watch out for negations when it comes to sentiments. Other negation words deserve attention, too:

```{r}
negation_words <- c("not", "no", "never", "without")

negated_words <- bigrams_separated %>%
  filter(word1 %in% negation_words) %>%
  inner_join(AFINN, by = c(word2 = "word")) %>%
  count(word1, word2, score, sort = TRUE) %>%
  ungroup()

negated_words
```

This only makes a small difference in the 5 interviews, but with a larger corpus we are bound to see more impact. We can compute and visualise the impact by computing a value `score * n`: 

```{r}
negated_words %>%
  mutate(contribution = n * score) %>%
  arrange(desc(abs(contribution))) %>%
  head(20) %>%
  mutate(word2 = reorder(word2, contribution)) %>%
  ggplot(aes(word2, n * score, fill = n * score > 0)) +
  geom_col(show.legend = FALSE) +
  xlab("Words preceded by \"not\"") +
  ylab("Sentiment score * number of occurrences") +
  coord_flip()
```

This also makes it visible that in the first 5 interviews there were no negatve words negated, such as "no doubt". 

### Graphing bigram networks 

```{r initialise igraph}
library(igraph)
```

The dataframe we need for this is `bigram_counts` with word1, word2 and n as the "weight". Let's use only the those with n GEG 2:


```{r}
bigram_graph <- bigram_counts %>%
  filter(n >= 2) %>%
  graph_from_data_frame()

bigram_graph
```
For plottigng we use ggraph:

```{r ggrpraph initaliased}
library(ggraph)
```

```{r}
set.seed(2017)

ggraph(bigram_graph, layout = "fr") +
  geom_edge_link() +
  geom_node_point() +
  geom_node_text(aes(label = name), vjust = 1, hjust = 1)
```

Not a particularly connected graph, but the principle is clear. 

### Correlations among questions

```{r}
library(widyr)
```

```{r}
word_pairs <- words_students %>%
  pairwise_count(word, Question, sort = TRUE)

word_pairs
```
These are pair counts per question. Here's the same for interviews: 

```{r}
word_pairs <- words_students %>%
  pairwise_count(word, Interview, sort = TRUE)

word_pairs
```
Note that these become rather big tables because so many things go togehter on that scale. We can also look this way for specific combinations of words. Let's go back to pairs within questions, and further reduce to the first interview:

```{r}
word_pairs <- words_students %>%
  filter(Interview == 1) %>%
  pairwise_count(word, Question, sort = TRUE)

word_pairs
```

Adn lets look for pairs that have "assignment" in them. Note that the level of counting is the Question. One problem is that we have questions with labels Q<i> and Q<i>-F, which in this analysis get counted separately. 


```{r}
word_pairs %>%
    filter(item1 == "assignment")
```

Let's calculate a correlation between (frequent) words:

```{r}
word_cors <- words_students %>%
  group_by(word) %>%
  filter(n() >= 20) %>%
  pairwise_cor(word, Question, sort = TRUE)

word_cors
```

Plots help to get an overview: 

```{r}
word_cors %>%
  filter(item1 %in% c("mark", "time", "idea", "assignment")) %>%
  group_by(item1) %>%
  top_n(6) %>%
  ungroup() %>%
  mutate(item2 = reorder(item2, correlation)) %>%
  ggplot(aes(item2, correlation)) +
  geom_bar(stat = "identity") +
  facet_wrap(~ item1, scales = "free") +
  coord_flip()
```

And based on correlations we can create a network graph: 

```{r}
set.seed(2016)

word_cors %>%
  filter(correlation > .15) %>%
  graph_from_data_frame() %>%
  ggraph(layout = "fr") +
  geom_edge_link(aes(edge_alpha = correlation), show.legend = FALSE) +
  geom_node_point(color = "lightblue", size = 5) +
  geom_node_text(aes(label = name), repel = TRUE) +
  theme_void()
```


# Topic models

In general, TMs classify documents into topics and determine the overlap of a document with a topic. Each topic is made up out of a number of words. 

## Casting the tidy text df into a document-term matrix

Most text mining packages use  DTM format, which is a matrix where:

* each row represents one document (such as a book or article),
* each column represents one term, and
* each value (typically) contains the number of appearances of that term in that document.

Here's how to turn a tidy text df into a DTM:

```{r}
library(tm)
```


```{r}
students_dtm <- words_students %>%
    count(Interview, word) %>%
    cast_dtm(Interview, word, n)

students_dtm
```

## Topics across interviews

With this we have a dtm for each of the 5 interviews, students' contributions only. Based on this we can mine for topics:

```{r}
library(topicmodels)

```

```{r}
# set a seed so that the output of the model is predictable
students_lda <- LDA(students_dtm, k = 2, control = list(seed = 1234))
students_lda
```
This object contains a model with just two groups, to make things easier. This model needs to be inspected to gain insights. For instance, we can look at how the words relate to the topics, extracting the `beta` value from the matrix. We use tidy to turn that column into a tibble topic-term-beta. The betas can be interpreted as probabilities or the term belonging to the topic. 

```{r}
students_topics <- tidy(students_lda, matrix = "beta")
students_topics
```
Let's look at the top-10 terms:

```{r}
students_top_terms <- students_topics %>%
  group_by(topic) %>%
  top_n(10, beta) %>%
  ungroup() %>%
  arrange(topic, -beta)
```

And visualise them:

```{r}
students_top_terms %>%
  mutate(term = reorder(term, beta)) %>%
  ggplot(aes(term, beta, fill = factor(topic))) +
  geom_col(show.legend = FALSE) +
  facet_wrap(~ topic, scales = "free") +
  coord_flip()
```

Due to the small corpus, and the fact that we have the same questions in all interviews, this leads not to topics which are easily interpreted. A corresponding analysis, kind of a validation question, would look into topics based on the questions. 

The alternative view is to look for terms which differ most between topics. 


```{r}
beta_spread <- students_topics %>%
  mutate(topic = paste0("topic", topic)) %>%
  spread(topic, beta) %>%
  filter(topic1 > .001 | topic2 > .001) %>%
  mutate(log_ratio = log2(topic2 / topic1))

beta_spread
```
> To do: Plot a graph with the highest (positive and negative) differences in log ratio. 

## Topics across questions

```{r}
students_dtm_questions <- words_students %>%
    count(Question, word) %>%
    cast_dtm(Question, word, n)

students_dtm_questions
```
We have 16 questions (documents) here because of the follow up questions. Really need to address that in the base model by introducing a column for follow up. In any case, 9 topics should be a good fit to the data. 

```{r}
students_lda_questions <- LDA(students_dtm_questions, k = 9)
students_lda_questions
```

```{r}
students_topics_questions <- tidy(students_lda_questions, matrix = "beta")
students_topics_questions
```




```{r}
students_top_terms_questions <- students_topics_questions %>%
  group_by(topic) %>%
  top_n(5, beta) %>%
  ungroup() %>%
  arrange(topic, -beta)
```

And visualise them:

```{r}
students_top_terms_questions %>%
  mutate(term = reorder(term, beta)) %>%
  ggplot(aes(term, beta, fill = factor(topic))) +
  geom_col(show.legend = FALSE) +
  facet_wrap(~ topic, scales = "free") +
  coord_flip()
```

Something like this could be used, with the overall corpus, to see if the nine questions yielded different answers, of if other semantic similarities show up. Question 5, for intance, really should be about facilitation. 

Also, by changing k we can explore goodness of fit perhaps, for alternative models. 


# Miscalleneous



## Stemming

This now also is the point were we also could do some stemming. For this we need this library:
```{r}
library(SnowballC)
```
Which gives us a function 'wordstem': 

```{r stemming}
words_stemmed <- mutate(words_df, word = wordStem(word))
head(words_stemmed, n=20L)
```
But we don't want to use the stemmed words just now  because it would intefere with the sentiment analysis. Stemming is useful, but only once we no longer need "real" words, such as for topic modelling and the likes.





# Appendices

## Lessons learned

To make analysis flexible, use a distinct variable name for the data set the analysis is based on, and bind it at the beginning of the analysis to the specific data set, which you expect will be varied. 




Interview Analysis (5 respondents)