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.

These are our main packages:

Additional packages for specific analyses:

Data import

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

text_df <- read_csv("Comments.csv")

The data come in the format CommentID, RespondentID, QuestionID, GroupID, CommentText

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.

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.

Let’s get to the words:

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

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)

Let’s look at punctuation:

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

There are more than 3000 words in the word column, many of which are not really words, but appear so because there is no space between the points. This would need to be addressed in the next round of cleaning, but for the moment we siimply remove all these.

Address this issue in the next round.

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 750.

words_df %>%
  count(word, sort = TRUE) %>%
  filter(n > 750) %>%
  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(RespondentID) %>% 
  count(word, sort = TRUE) %>% 
  left_join(words_df %>% 
              group_by(RespondentID) %>% 
              summarise(total = n())) %>%
  mutate(freq = n/total)

Joining, by = "RespondentID"

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)

Word cloud

This uses the library wordcloud:

words_df %>%
  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_df %>%
  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_df %>%
  filter(QuestionID == 3861750) %>%
  inner_join(nrc_joy) %>%
  count(word, sort = TRUE)

Joining, by = "word"

Sentiment on all questions

words_df %>%
  group_by(QuestionID) %>%
  inner_join(nrc_joy) %>%
  count(word, sort = FALSE)

Joining, by = "word"

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

This not particularly useful here, but you get the idea:

words_dfs %>%
  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_df %>%
  inner_join(get_sentiments("bing")) %>%
  count(word, sentiment, sort = TRUE) %>%
  ungroup()

Joining, by = "word"

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_df %>%
  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

Frequencies by some unit of analysis, like by question or some other category. Here I demonstrate how to do this by GroupID. Not sure that make sense; it would if one had reasons to expect that the/some groups are different.

Calculating term frequency per group

Whole 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.

group_words <- words_df %>%
  count(GroupID, word, sort = TRUE) %>%
  ungroup()

head(group_words)

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

Step 2: total of words per group

total_words <- group_words %>% 
  group_by(GroupID) %>% 
  summarize(total = sum(n))

total_words

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

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. To make this visually inspectable, we filter out “question” and facet on a smaller number of groups. (A better solution requires fiddling with the geom_histrogram.)

group_words_small <- group_words %>% 
  filter(GroupID <  19235 & word != "question") 

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

tf_idf For students reponses only

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

group_words <- group_words %>%
  bind_tf_idf(word, GroupID, n)
head(group_words)

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

group_words %>%
  arrange(desc(tf_idf))

We can plot this result (again, only on the first 8 groups for visibility)

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

Selecting by tf_idf

Todo: unpack the mutate line

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)

Loading required package: NLP

Attaching package: ‘NLP’

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

    annotate

First we filter out the overly frequent word “question(s)” and some other words which are necessarily frequent because they refer to the mcq genre. And there’s that number which also needs to go.

# remove question from corpus
words_df <- words_df  %>%
  filter(word != "question") %>%
  filter(word != "questions") %>%
  filter(word != "option") %>%
  filter(word != "options") %>%
  filter(word != "answer") %>%
  filter(word != "answers") %>%
  filter(word != "mcq") %>%
  filter(word != "327029")

students_dtm <- words_df %>%
    count(QuestionID, word) %>%
    cast_dtm(QuestionID, word, n)

students_dtm

<<DocumentTermMatrix (documents: 1670, terms: 9996)>>
Non-/sparse entries: 135820/16557500
Sparsity           : 99%
Maximal term length: 24
Weighting          : term frequency (tf)

Topics across questions

With this we have a dtm for each of the questions. 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 = 5, control = list(seed = 1234))
students_lda

A LDA_VEM topic model with 5 topics.

This object contains a model with five groups. 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()

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.

Relationship between words - N-grams

NOT MODIFIED YET FOR COMMENTS ANALYSIS

bigrams <- text_df %>%
  unnest_tokens(bigram, Text, token = "ngrams", n = 2)

head(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).

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)

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()

bigram_graph

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_df %>%
  pairwise_count(word, Question, sort = TRUE)

word_pairs

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

word_pairs <- words_df %>%
  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_df %>%
  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_df %>% 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()

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()

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: "Peerwise Comments Analysis (12100 comments)"
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.

These are our main packages:
```{r include=FALSE}
library(tidyverse)
library(tidytext)
```

Additional packages for specific analyses:


```{r include=FALSE}
library(wordcloud)
library(igraph)
library(ggraph)
library(widyr)
library(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("Comments.csv")
```

The data come in the format CommentID, RespondentID, QuestionID, GroupID, CommentText

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. 


## 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. 

Let's get to the words: 

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

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)
```

Let's look at punctuation: 

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

There are more than 3000 words in the word column, many of which are not really words, but appear so because there is no space between the points. This would need to be addressed in the next round of cleaning, but for the moment we siimply remove all these. 

> Address this issue in the next round. 

```{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 750. 

```{r}
words_df %>%
  count(word, sort = TRUE) %>%
  filter(n > 750) %>%
  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(RespondentID) %>% 
  count(word, sort = TRUE) %>% 
  left_join(words_df %>% 
              group_by(RespondentID) %>% 
              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)
```


### Word cloud

This uses the library wordcloud: 

```{r}
words_df %>%
  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_df %>%
  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_df %>%
  filter(QuestionID == 3861750) %>%
  inner_join(nrc_joy) %>%
  count(word, sort = TRUE)
```


### Sentiment on all questions

```{r}
words_df %>%
  group_by(QuestionID) %>%
  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

This not particularly useful here,  but you get the idea:

```
words_dfs %>%
  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_df %>%
  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_df %>%
  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

Frequencies by some unit of analysis, like by question or some other category. Here I demonstrate how to do this by GroupID. Not sure that make sense; it would if one had reasons to expect that the/some groups are different. 

## Calculating term frequency per group

### Whole 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}
group_words <- words_df %>%
  count(GroupID, word, sort = TRUE) %>%
  ungroup()

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


Step 2: total of words per group
```{r}
total_words <- group_words %>% 
  group_by(GroupID) %>% 
  summarize(total = sum(n))

total_words
```

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

```{r}
group_words <- left_join(group_words, total_words, by = "GroupID")
head(group_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. To make this visually inspectable, we filter out "question" and facet on a smaller number of groups. (A better solution requires fiddling with the geom_histrogram.)

```{r}
group_words_small <- group_words %>% 
  filter(GroupID <  19235 & word != "question") 

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



### tf_idf For students reponses only

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

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

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

We can plot this result (again, only on the first 8 groups for visibility)

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



# 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)
```
First we filter out the overly frequent word "question(s)"  and some other words which are necessarily frequent because they refer to the mcq genre. And there's that number which also needs to go.

```{r}
# remove question from corpus
words_df <- words_df  %>%
  filter(word != "question") %>%
  filter(word != "questions") %>%
  filter(word != "option") %>%
  filter(word != "options") %>%
  filter(word != "answer") %>%
  filter(word != "answers") %>%
  filter(word != "mcq") %>%
  filter(word != "327029")
```


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

students_dtm
```

## Topics across questions

With this we have a dtm for each of the questions. 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 = 5, control = list(seed = 1234))
students_lda
```
This object contains a model with five groups. 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()
```



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. 


# Relationship between words - N-grams

> NOT MODIFIED YET FOR COMMENTS ANALYSIS

```{r}
bigrams <- text_df %>%
  unnest_tokens(bigram, Text, token = "ngrams", n = 2)

head(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)`. 


### 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_df %>%
  pairwise_count(word, Question, sort = TRUE)

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

```{r}
word_pairs <- words_df %>%
  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_df %>%
  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_df %>%
  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()
```



# 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. 




Peerwise Comments Analysis (12100 comments)