annotated_data.Rmd

---
title: "Untersuchungen mit dem annotierten Korpus"
author: "Anina Klaus, Katja Konermann und Niklas Stepczynski"
output: html_document
---

```{r setup, message=FALSE, warning=FALSE}
library(quanteda)
library(readtext)
library(udpipe)
library(tidyverse)
```

Benötigte _libraries_:

- quanteda: Korpus erstellen

- readtext: Dateien sinnvoll einlesen

- udpipe: Korpus annotieren

- tidyverse: viele R-Funktionen und ggplot

### Vorbereitung des Korpus

Zunächst muss der Korpus eingelesen werden:

```{r program}
programs <- readtext("Korpus-Dateien", 
                     docvarsfrom = "filenames",
                     docvarnames = c("type", "party", "year"),
                     dvsep = "-",
                     encoding="utf-8") %>% corpus()
```

### Vorbereitung der Sentimentdaten

Für die Sentimentanalyse verwenden wir das SentiWS-Wörterbuch. Es wird als _data.frame_ gespeichert, in der ersten Spalte findet sich der Term, in der Zweiten der dazugehörige Sentimentwert. Die Erstellung des Sentiment-Dictionaries wird im Abschnitt "Sentiment" gezeigt.

```{r sentiment}
# Load sentiment dictionary
load("RData/senti_dict.RData")
```

Außerdem muss der annotierte Korpus geladen werden.

```{r annotate}
load("RData/annotated_corpus.RData")
head(annotated_model)[c(1:3,5:13)]
```

Die .RData-Datei wurde mit dem folgenden Code erstellt, das Annotieren des gesamten Korpus dauert allerdings seine Zeit.

```{r eval=FALSE}
annotated_model <- udpipe_annotate(udmodel_german, x = programs) %>%
  as.data.frame()
save(annotated_model, file='annotated_corpus.RData')
```

Im nächsten Schritt wird der Korpus aufgeteilt, je nachdem, ob das Wahlprogramm durch eine regierungsbeteiligte Partei erstellt wurde oder durch eine Partei der Opposition.

```{r subcorpora}
# partition of corpus
regierung <- c('doc3', 'doc4', 'doc10', 'doc11', 'doc12', 'doc19', 'doc23', 'doc24', 'doc25', 'doc27')
opposition <- c('doc1', 'doc2', 'doc5', 'doc6', 'doc7', 'doc8', 'doc9', 'doc13', 'doc14', 'doc15', 'doc16', 'doc17', 'doc18', 'doc20', 'doc21', 'doc22', 'doc26')

# split into 
sub_model_regierung <- subset(annotated_model, doc_id %in% regierung)
sub_model_opposition <- subset(annotated_model, doc_id %in% opposition)
```

Im folgenden haben wir zwei Listen (das etwas komplizierte R-Äquivalent zu _dictionaries_ in Python), in denen für jedes Dokument die Begriffe gespeichert sind, mit denen die Verfasserin auf sich selbst referieren könnte.

```{r zuordnungen}
# list of words a party could use to talk about themselves
# first one is name of the party
regierung_list <- list('doc3' = c('bündnis90/die grünen', 'wir'),
                       'doc4' = c('bündnis90/die grünen', 'wir'),
                       'doc10' = c('cdu', 'wir'),
                       'doc11' = c('cdu', 'wir'),
                       'doc12' = c('cdu', 'wir'),
                       'doc19' = c('fdp', 'wir'),
                       'doc23' = c('spd', 'wir'),
                       'doc24' = c('spd', 'wir'),
                       'doc25' = c('spd', 'wir'),
                       'doc27' = c('spd', 'wir'))

opposition_list <- list('doc1' = c('afd', 'alternative', 'wir'),
                        'doc2' = c('afd', 'alternative', 'wir'),
                        'doc5' = c('bündnis90/die grünen', 'bündnis90', 'grüne', 'wir'),
                        'doc6' = c('bündnis90/die grünen', 'bündnis90', 'grüne', 'wir'),
                        'doc7' = c('bündnis90/die grünen', 'bündnis90', 'grüne', 'wir'),
                        'doc8' = c('cdu', 'wir'),
                        'doc9' = c('cdu', 'wir'),
                        'doc13' = c('die linke', 'linke', 'wir'),
                        'doc14' = c('die linke', 'linke', 'wir'),
                        'doc15' = c('die linke', 'linke', 'wir'),
                        'doc16' = c('fdp', 'wir'),
                        'doc17' = c('fdp', 'wir'),
                        'doc18' = c('fdp', 'wir'),
                        'doc20' = c('fdp', 'wir'),
                        'doc21' = c('pds', 'wir'),
                        'doc22' = c('linkspartei.pds', 'wir'),
                        'doc26' = c('spd', 'wir'))
```

Hiermit sollen jene Verben gesammelt werden, mit denen Parteien Aussagen über sich selbst treffen. Dazu helfen uns die folgenden beiden Funktionen:

### featsinfo_to_column

```{r funktion1}
# function to extract info from "feats"-column to separate column
featsinfo_to_column <- function(data, name) {
  data <- cbind(data, c('-'))
  names(data)[length(names(data))] <-  tolower(name)
  # separate data
  data_part1 <- data[grepl(name, data$feats) == TRUE,]
  data_part2 <- data[grepl(name, data$feats) == FALSE,]
  # extract data
  pattern <- paste0(".*(", name, "=)([A-Za-z]+)[|]?.*")
  data_part1[,ncol(data)] <- sub(pattern, "\\2",
                                 data_part1$feats)
  modified_data <- rbind(data_part1, data_part2)
  return(modified_data)
}
```

_featsinfo_to_column(annotated_data, translation_list, senti_data)_:

- _annotated_data_ ist ein mit _udpipe_ annotierter (Teil-)Korpus

- _name_ ist der (großgeschriebene) Name des Features, welches aus der Spalte _feats_ extrahiert werden soll.

Diese fügt eine neue Spalte an das Dataframe an, in welche die Information zum Feature gespeichert wird.

### roots_for_group

```{r}
roots_for_group <- function(annotated_data, translation_list, senti_data) {
  # extract roots
  roots <- annotated_data %>%
    subset(sentence %in% subset(., dep_rel == 'nsubj' & tolower(token) %in% unlist(translation_list[doc_id]))$sentence) %>%
    subset(dep_rel == 'root')
  
  # extract relevant information from "feats" column
  roots <- roots[c(1, 6:7, 10)] %>%
    featsinfo_to_column('Tense') %>%
    featsinfo_to_column('Mood') %>%
    featsinfo_to_column('VerbForm')

  roots <- roots[-c(2,4)]  # cut out feats and token
  
  roots$senti_ws <- '-'  # add sentiment column
  for (w in unique(roots$lemma)) {
    if (w %in% senti_data$term) {
      if (length(senti_data[senti_data$term == w,]$value) < 2) {
        roots[roots$lemma == w,]$senti_ws <- senti_data[senti_data$term == w,]$value
      }
    }
  }
  
  # count words
  roots <- roots[2:6]
  roots <- aggregate(cbind(roots[0],numdup=1), roots, length)
  roots <- roots[order(roots$numdup, decreasing = TRUE),] %>%
    filter(numdup > 2)
  names(roots)[names(roots) == 'numdup'] <- 'freq'
  
  return(roots)
}
```

_roots_for_group(annotated_data, translation_list, senti_data)_:

- _annotated_data_ ist ein mit _udpipe_ annotierter (Teil-)Korpus

- _translation_list_ ist eine Liste nach dem Stil der Listen _regierung_list_ und _opposition_list_, in der für jedes Dokument mögliche Subjekte gesammelt sind, zu welchen Verben gesammelt werden sollen (s.o.).

- _senti_data_ ist ein _data.frame_ wie oben beschrieben, mit einer Spalte _term_ und einer Salte _value_

Diese Funktion sammelt die Lemmata der Verben, mit denen Parteien ihr eigenes Handeln beschreiben und speichert allerlei Informationen über sie. Gesammelt werden _tense_, _mood_, _verbform_, Semtimentwert sowie Häufigkeit.

```{r test_roots_for_group}
translation_complete <- c(regierung_list, opposition_list)
head(roots_for_group(annotated_model, translation_complete, senti_dict))
```



### collect_sentiment_for_cat

Die folgende Funktion sammelt Sentimentwerte und Frequenz für beliebige Werte einer Kategorie.

_collect_sentiment_for_cat(annotated_data, category, value, senti_data):_

- _annotated_data_ ist ein mit _udpipe_ annotierter (Teil-)Korpus

- _category_ ist die Spalte, in der gesucht werden soll.

- _value_ der Wert, nach dem gefiltert werden soll.

```{r generalstuff}
# function to collect sentiment for category
collect_sentiment_for_cat <- function(annotated_data, category, value, senti_data) {
  # filter data
  index <- grep(category, colnames(annotated_data))
  filtered_data <- subset(annotated_data, annotated_data[,index] == value)
  filtered_data$senti_ws <- '-'
  senti_df <- filtered_data[c(7,8)]
  
  senti_df$senti_ws <- '-'  # add sentiment column
  for (w in unique(senti_df$lemma)) {
    if (w %in% senti_data$term) {
      if (length(senti_data[senti_data$term == w,]$value) < 2) {
        senti_df[senti_df$lemma == w,]$senti_ws <- senti_data[senti_data$term == w,]$value
      }
    }
  }
  # count words
  senti_df <- aggregate(cbind(senti_df[0],numdup=1), senti_df, length)
  senti_df <- senti_df[order(senti_df$numdup, decreasing = TRUE),] %>%
    filter(numdup > 1)
  names(senti_df)[names(senti_df) == 'numdup'] <- 'freq'
  return(senti_df[-2])
}
```

Das Ergebnis sieht wiefolgt aus:

```{r}
opp_nouns <- collect_sentiment_for_cat(sub_model_opposition, "upos", 'NOUN', senti_dict)
head(opp_nouns)
gov_nouns <- collect_sentiment_for_cat(sub_model_regierung, "upos", 'NOUN', senti_dict)
head(gov_nouns)
opp_adv <- collect_sentiment_for_cat(sub_model_opposition, "upos", 'ADJ', senti_dict)
head(opp_adv)
gov_adv <- collect_sentiment_for_cat(sub_model_regierung, "upos", 'ADJ', senti_dict)
head(gov_adv)
```


### Auswertung der Daten: Gegenüberstellung von Regierung und Opposition

#### Frequenz

Mithilfe der durch _roots_for_group_-Funktion lassen sich jene Prädikate sammeln, welche die Parteien verwenden, wenn sie in ihren Programmen Aussagen über sich selbst tätigen, also in Sätzen wie "Wir forden..." oder "Die FDP befürwortet...". Zunächst haben wir überprüft, wie sich die quantitative Verteilung der Verwendung dieser Prädikate für Regierungs- und Oppositionsparteien gestaltet.

Der erste Schritt ist die Erstellung der _root_-Dataframes für die Subsets des annotierten Modells.

```{r}
opp_roots <- roots_for_group(sub_model_opposition, opposition_list, senti_dict)
head(opp_roots)
gov_roots <- roots_for_group(sub_model_regierung, regierung_list, senti_dict)
head(gov_roots)
```

Zunächst betrachten wir also die Frequenz. Nach der Erstellung eines Dataframes, welches die Top50-Prädikate der Oppositionswahlprogramme mit den Top50-Prädikaten der Regierungswahlprogramme vereinigt, sowie der Normalisierung der Werte kann man die Verteilung plotten.

```{r}
# Self referential verbs
verbs.top.50 <- union(head(gov_roots, 50)$lemma, head(opp_roots, 50)$lemma)
freq.verbs <- data.frame(matrix(ncol=3, nrow=0))
colnames(freq.verbs) <- c("lemma", "freq_gov", "freq_opp")
sum.all.gov <- sum(gov_roots$freq)
sum.all.opp <- sum(opp_roots$freq)
for (i in 1:length(verbs.top.50)){
  curr.verb <- verbs.top.50[i]
  freq.gov <- sum(filter(gov_roots, lemma == curr.verb)$freq)/sum.all.gov
  freq.opp <- sum(filter(opp_roots, lemma == curr.verb)$freq)/sum.all.opp
  curr.row <- data.frame(lemma=curr.verb, freq_gov=freq.gov, freq_opp = freq.opp)
  freq.verbs <- rbind(freq.verbs, curr.row)
}
freq.verbs
gov.greater <- ifelse(freq.verbs$freq_gov >= freq.verbs$freq_opp, TRUE, FALSE)
freq.verbs$gov.greater <- gov.greater
```

```{r, fig.height=10, fig.width=12}
# Plot results
ggplot(freq.verbs, aes(y = freq_gov, x = freq_opp, label =lemma, color = gov.greater))+
  geom_text(size = 5)+
  scale_x_continuous(trans = 'log10', breaks = c(0, 0.001, 0.010, 0.1)) +
  scale_y_continuous(trans = 'log10', breaks = c(0, 0.001, 0.010, 0.05))+
  scale_color_manual(values = c('TRUE' = 'darkblue', 'FALSE' = 'darkred'), guide = "none")+
  theme_minimal()+
  labs(x="Relative Frequenz in Oppositionsparteien",
       y="Relative Frequenz in Regierungsparteien",
       title="Verben in selbstreferentiellen Sätzen")+
  theme(axis.text=element_text(size=16),
        axis.title=element_text(size=20))
```

#### Tense

Auch die Zeitformen der Verben werden durch die Funktion _roots_for_groops_ festgehalten und können so gegenübergestellt werden:

```{r}
## TENSE
s.gov <- sum(gov_roots$freq)
s.opp <- sum(opp_roots$freq)

gov.type <- c("opposition", "goverment")
pres.type <- c(sum(filter(opp_roots, tense == "Pres")$freq)/s.opp,
               sum(filter(gov_roots, tense == "Pres")$freq)/s.gov)
past.type <- c(sum(filter(opp_roots, tense == "Past")$freq)/s.opp,
               sum(filter(gov_roots, tense == "Past")$freq)/s.gov)

tense <- data.frame(type=gov.type, pres =pres.type, past=past.type)
tense
```

#### VerbForm

Gleiches ist möglich für die Kategorie "VerbForm":

```{r}
## VERBFORM

inf.type <-  c(sum(filter(opp_roots, verbform == "Inf")$freq)/s.opp,
               sum(filter(gov_roots, verbform == "Inf")$freq)/s.gov)
fin.type <- c(sum(filter(opp_roots, verbform == "Fin")$freq)/s.opp,
              sum(filter(gov_roots, verbform == "Fin")$freq)/s.gov)
part.type <- c(sum(filter(opp_roots, verbform == "Part")$freq)/s.opp,
               sum(filter(gov_roots, verbform == "Part")$freq)/s.gov)

verbform <- data.frame(type=gov.type, inf=inf.type, fin =fin.type, part = part.type)
verbform
```

#### Sentiment nach Kategorie

Mit der Funktion _sentiment_for_cat_ lassen sich Sentimentwerte und Frequenzen für Tokens einer bestimmten Kategorie sammeln. Im folgenden wurden zunächst die Werte für Substantive und Adjektive gesammelt.

```{r}
opp_nouns <- collect_sentiment_for_cat(sub_model_opposition, "upos", 'NOUN', senti_dict)
gov_nouns <- collect_sentiment_for_cat(sub_model_regierung, "upos", 'NOUN', senti_dict)
opp_adv <- collect_sentiment_for_cat(sub_model_opposition, "upos", 'ADJ', senti_dict)
gov_adv <- collect_sentiment_for_cat(sub_model_regierung, "upos", 'ADJ', senti_dict)

head(opp_nouns)
head(gov_nouns)
```

Als nächstes folgt die Normalisierung der Frequenzwerte:

```{r}
## top nouns opposition und Government
noun.top <- union(head(opp_nouns, 60)$lemma, head(gov_nouns, 40)$lemma)

sum.gov <- sum(gov_nouns$freq)
sum.opp <- sum(opp_nouns$freq)
freq.nouns <- data.frame(matrix(ncol=3, nrow=0))
colnames(freq.nouns) <- c("lemma", "freq_gov", "freq_opp")

for (i in 1:length(noun.top)){
  curr.noun <- noun.top[i]
  gov.freq <- sum(filter(gov_nouns, lemma == curr.noun)$freq)/sum.gov
  opp.freq <- sum(filter(opp_nouns, lemma == curr.noun)$freq)/sum.opp
  tmp.data <- data.frame(lemma=curr.noun, gov_freq = gov.freq, opp_freq = opp.freq)
  freq.nouns <- rbind(freq.nouns, tmp.data)
  
}
freq.nouns$gov.greater <- ifelse(freq.nouns$gov_freq >= freq.nouns$opp_freq, TRUE, FALSE)
```

Und schließlich der resultierende Plot:

```{r, fig.height=10, fig.width=12}
ggplot(freq.nouns, aes(y = gov_freq, x = opp_freq, label =lemma, color = gov.greater))+
  geom_text(size = 5)+
  scale_x_continuous(trans = 'log10', breaks = c(0, 0.001, 0.010, 0.1)) +
  scale_y_continuous(trans = 'log10', breaks = c(0, 0.001, 0.010, 0.05)) +
  scale_color_manual(values = c('TRUE' = 'darkblue', 'FALSE' = 'darkred'), guide = "none")+
  theme_minimal() +
  labs(x="Relative Frequenz in Oppositionsparteien",
       y="Relative Frequenz in Regierungsparteien",
       title="Häufige Nomen bei Oppositions- und Regierungsparteien")+
  theme(axis.text=element_text(size=16),
        axis.title=element_text(size=20))
```

Diese Prozedur funktioniert analog für Adjektive:

```{r}
## OPP GOV ADJ
head(opp_adv)
head(gov_adv)

adj.top <- union(head(opp_adv, 50)$lemma, head(gov_adv, 50)$lemma)

sum.gov <- sum(gov_adv$freq)
sum.opp <- sum(opp_adv$freq)
freq.adj <- data.frame(matrix(ncol=3, nrow=0))
colnames(freq.nouns) <- c("lemma", "freq_gov", "freq_opp")

for (i in 1:length(adj.top)){
  curr.adj <- adj.top[i]
  gov.freq <- sum(filter(gov_adv, lemma == curr.adj)$freq)/sum.gov
  opp.freq <- sum(filter(opp_adv, lemma == curr.adj)$freq)/sum.opp
  tmp.data <- data.frame(lemma=curr.adj, gov_freq = gov.freq, opp_freq = opp.freq)
  freq.adj <- rbind(freq.adj, tmp.data)
  
}

freq.adj$gov.greater <- ifelse(freq.adj$gov_freq >= freq.adj$opp_freq, TRUE, FALSE)
```

```{r, fig.height=10, fig.width=12}
ggplot(freq.adj, aes(y = gov_freq, x = opp_freq, label =lemma, color = gov.greater)) +
  geom_text(size = 5) +
  scale_x_continuous(trans = 'log10', breaks = c(0, 0.005, 0.010, 0.020)) +
  scale_y_continuous(trans = 'log10', breaks = c(0, 0.020, 0.010, 0.005)) +
  scale_color_manual(values = c('TRUE' = 'darkblue', 'FALSE' = 'darkred'), guide = "none")+
  theme_minimal() +
  ggtitle("Häufige Adjektive bei Oppositions- und Regierungsparteien") +
  labs(x="Relative Frequenz in Oppositionsparteien",
       y="Relative Frequenz in Regierungsparteien") +
  theme(axis.text=element_text(size=16),
        axis.title=element_text(size=20))
```

### Sentimentwerte der Adjektive

Auch die Sentimentwerte für einzelne Kategorien lassen sich so analysieren. 
Nach der Aufsummierung der Addjektive lässt sich ein Dataframe erstellen:

```{r}
# Government
adj.s.gov <- sum(gov_adv$freq)

tmp.sent <- ifelse(gov_adv$senti_ws == "-", 0, gov_adv$senti_ws)
gov_adv$tmp.sent <- as.numeric(tmp.sent)

neg.adj <- filter(gov_adv, tmp.sent<0)
f <- abs(sum(neg.adj$tmp.sent * neg.adj$freq/adj.s.gov))

pos.adj <- filter(gov_adv, tmp.sent>0)
g <- sum(pos.adj$tmp.sent * pos.adj$freq/adj.s.gov)

# Opposition
adj.s.opp <- sum(opp_adv$freq)
tmp.sent <- ifelse(opp_adv$senti_ws == "-", 0, opp_adv$senti_ws)
opp_adv$tmp.sent <- as.numeric(tmp.sent)

neg.adj <- filter(opp_adv, tmp.sent<0)
h <- abs(sum(neg.adj$tmp.sent * neg.adj$freq/adj.s.opp))

pos.adj <- filter(opp_adv, tmp.sent>0)
i <- sum(pos.adj$tmp.sent * pos.adj$freq/adj.s.opp )

adv_senti <- c('positive', 'negative', 'positive', 'negative')
combi_assignment <- c('Regierung', 'Regierung', 'Opposition', 'Opposition')

adv_senti_df <- data.frame(adv_senti, combi_assignment)
adv_senti_df$Wert <- c(g, f, i, h)
adv_senti_df
```

Der Plot sieht wiefolgt aus:

```{r}
adv_senti_plot <- ggplot(adv_senti_df, aes(x=adv_senti, y=Wert, fill=combi_assignment)) +
  geom_bar(stat='identity', position='dodge') +
  xlab('Sentiment') +
  ylab('kumulierter Wert') +
  ggtitle('kumulierte Sentimentwerte für Adjektive') +
  guides(fill=guide_legend(title="Position")) + 
  scale_fill_manual("Position", values = c("Opposition" = "darkred", "Regierung" = "darkblue"))
adv_senti_plot
```