---
title: "Vorlesung 4: tidyverse & Abbildungen (Teil 2)"
author: "Jonathan Harrington / Johanna Cronenberg"
date: "Mai 2021"
output: 
  html_document:
    number_sections: TRUE
    toc: true
    theme: flatly
    highlight: pygments
---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

```{r klippy, echo=FALSE, include=TRUE}
klippy::klippy(position = c('top', 'right'))
```

<style>
div.green {background-color: #ecffeb; border-radius: 5px; padding: 20px;}
div.gray {background-color: #e8e8e8; border-radius: 5px; padding: 20px;}
</style>

# Packages und Daten laden

Starten Sie das R Projekt, das Sie für diesen Kurs angelegt haben. Öffnen Sie hierfür RStudio und benutzen Sie die Schaltfläche oben rechts oder navigieren Sie zu Ihrem Kursverzeichnis und klicken Sie auf die `.Rproj` Datei. 

Laden Sie dann die folgenden Packages:

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

Wir werden diese Woche wieder mit verschiedenen Data Frames arbeiten, die wir vom IPS-Server laden. Die URL legen wir als Variable an und benutzen diese dann in der Funktion `file.path()`.

```{r}
url <- "http://www.phonetik.uni-muenchen.de/~jmh/lehre/Rdf"
asp <- read.table(file.path(url, "asp.txt"))
coronal <- read.table(file.path(url, "coronal.txt"))
```

# Daten aufräumen mit `tidyr`

"*tidy datasets are all alike but every messy dataset is messy in its own way*" -- Hadley Wickham

Hadley Wickham ist der Chef-Entwickler des *tidyverse*. Die Funktionen des *tidyverse* sind nicht nur auf Datenmanipulation und -verarbeitung ausgerichtet, sondern auch auf das Aufräumen von Datensätzen. 

Ein aufgeräumter Datensatz folgt drei Prinzipien:

* Jede Spalte enthält eine Variable
* Jede Zeile enthält eine Beobachtung
* Jede Zelle enthält einen Wert

Diese Grundsätze scheinen zunächst offensichtlich, werden Ihnen aber in der täglichen Arbeit mit Daten in R immer wieder begegnen. Die drei Prinzipien sollten Sie vor allem aus zwei Gründen befolgen: Erstens ist jeder Datensatz so auf dieselbe konsistente Weise strukturiert, was Ihnen jede Analyse erleichtern wird. Zweitens sind die Funktionen in R, aber insbesondere die Funktionen des *tidyverse* auf die Arbeit mit Spalten ausgelegt. Das heißt, Sie wenden Funktionen häufig auf einzelne Spalten an. Deshalb ist es sinnvoll, wenn jede Spalte eine Variable enthält. Um dies zu verdeutlichen, zeigen wir Ihnen im Folgenden Beispiele für die zwei häufigsten Arten von *messy data*.

- *Spaltennamen sind nicht Variablen, sondern Werte*: Die Spalten `schnell` und `langsam` sind eigentlich Werte der Variable `Tempo`.

```{r}
avokal <- read.table(file.path(url, "avokal.txt"))
avokal
```

- *Mehrere Variablen sind in einer Spalte gespeichert*: In der Spalte `Context` sind zwei Informationen abgespeichert: der linke und der rechte phonetische Kontext. Besser ist die Aufteilung in zwei Spalten, die sogar auch schon im Data Frame existieren (`Left` und `Right`).

```{r}
vcv <- read.table(file.path(url, "vcvC.txt"))
vcv %>% head()
```

Es ist nicht trivial, einen Data Frame sauber zu strukturieren. Nur ein Beispiel: Sie haben die ersten vier Formanten in Vokalen gemessen. Ist es sinnvoller, die erhobenen Daten in vier Spalten `F1`, `F2`, `F3`, `F4` festzuhalten? Oder besser in zwei Spalten `Hz` (mit den Formantwerten in Hertz) und `Formant` (mit den Werten 1, 2, 3 oder 4)?

Bevor wir Ihnen zeigen, wie Sie die obigen Datensätze so umformen können, dass sie den drei Prinzipien für aufgeräumte Daten folgen, möchten wir Ihnen noch die **tibble** vorstellen.

## Tibbles

Die *tibble* ist eine vereinfachte Form eines Data Frames, die im *tidyverse* häufig verwendet wird. Wir laden hier einen weiteren Data Frame und formen ihn danach mittels `as_tibble()` um:

```{r}
vdata <- read.table(file.path(url, "vdata.txt")) %>% 
  as_tibble()
```

Wenn wir den Namen der *tibble* jetzt in die Konsole eingeben, wird nicht wie beim Data Frame üblich der gesamte Datensatz angezeigt, sondern nur die ersten zehn Zeilen. Wir sehen außerdem, aus wie vielen Zeilen und Spalten die *tibble* besteht und welcher Objektklasse die einzelnen Spalten angehören:

```{r}
vdata
```

Die *tibble* hat vorrangig die Klasse `tbl_df`, aber zusätzlich noch `tbl` und `data.frame`. Wir werden deshalb im Folgenden trotzdem noch von Data Frames sprechen, wenn wir genau genommen eine *tibble* meinen.

```{r}
vdata %>% class()
```

Natürlich können Sie eine *tibble* auch selbst erstellen, indem Sie die Funktion `tibble()` anstelle der Funktion `data.frame()` verwenden, zum Beispiel so:

```{r}
tibble(x = 1:5, y = 6:10)
```

Wenn Sie die Import-Funktion `read_delim()` aus dem *tidyverse*-Package `readr` anstelle der `read.table()` Funktion verwenden, wird der Datensatz automatisch als *tibble* geladen:

```{r}
int <- read_delim(file.path(url, "intdauer.txt"), 
                  delim = " ", 
                  col_names = c("idx", "Vpn", "dB", "Dauer"), 
                  skip = 1)
int
```

`read_delim()` gibt Ihnen auch die Objektklasse für jede Spalte in der *Column specification* aus. Die Import-Funktionen aus `readr` sind etwas empfindlicher als die Standard-Funktionen in R. Hier mussten wir zum Beispiel einige Argumente spezifieren (`delim`, `col_names` und `skip`), um damit umzugehen, dass der Data Frame Zeilenindizes enthält. Die Standard-Funktion `read.table()` kommt hingegen meist damit klar, dass man nur den Pfad zum Datensatz angibt.

<div class="gray">
**Weiterführende Infos: Tibbles und `readr`**

Wenn Sie mehr über die *tibble* erfahren möchten, empfehlen wir [Kapitel 10 aus *R for Data Science*](https://r4ds.had.co.nz/tibbles.html).

Das Paket `readr` stellt noch weitere Funktionen zum Laden und Abspeichern von Datensätzen bereit, je nachdem wie die Spalten getrennt werden:

- `read_csv()`: **c**omma **s**eparated **v**alues, d.h. durch Komma getrennte Spalten
- `read_csv2()`: durch Semikolon getrennte Spalten
- `read_tsv()`: durch Tab getrennte Spalten
- `read_delim()`: für alle Trennzeichen geeignet

All dies und mehr finden Sie auch in [Kapitel 11 aus *R for Data Science*](https://r4ds.had.co.nz/data-import.html).

</div>

## Pivoting

Wenn wir unsere Daten geladen haben, fangen wir mit dem Aufräumen an. Das Ziel ist entweder, dass die Daten so strukturiert sind, dass jede Zeile eine neue Beobachtung enthält und dass die Spalten jeweils eine Variable enthalten. Das Ziel kann auch sein, dass die Daten so strukturiert sind, dass sie unserem Zweck dienen (z.B. dem Erstellen einer Abbildung). `tidyr` nennt diesen Prozess **pivoting** und es gibt eine gut erklärte Vignette zu dem Thema:

```{r, eval = F}
vignette("pivot")
```

Oben haben wir den Data Frame `avokal` geladen und haben festgestellt, dass die Spalten `schnell` und `langsam` eigentlich zwei Ausprägungen der Variable `Tempo` sind. Das heißt, es wäre besser, eine Spalte namens `Tempo` (Werte: "schnell", "langsam") und eine namens `Dauer` (Werte aus `schnell` und `langsam` in Millisekunden) zu haben:

```{r}
avokal %>% 
  pivot_longer(cols = c(schnell, langsam), 
               names_to = "Tempo", 
               values_to = "Dauer")
```

Der Befehl **`pivot_longer()`** wandelt den Data Frame in das so genannte "lange Format" um. Am wichtigsten sind die folgenden drei Argumente:

- `cols`: alle Spalten, die umwandelt werden sollen
- `values_to`: der Name der neuen Spalte mit den Werten
- `names_to`: der Name der neuen Spalte mit den ehemaligen Spaltennamen

Die Pivoting-Funktionen von `tidyr` sind sehr mächtig und können auch deutlich kompliziertere Operationen durchführen. Nehmen wir den [Data Frame `billboard`](https://tidyr.tidyverse.org/reference/billboard.html), der automatisch mit dem `tidyverse` geladen wird und die Rankings der Billboard Charts aus dem Jahr 2000 enthält:

```{r}
billboard
```

Auch hier ist es der Fall, dass die Spalten `wk1`, `wk2`, `wk3` usw. eigentlich Levels oder Ausprägungen der Variable `week` sind. Wir möchten also eine Spalte erstellen, die uns die Woche angibt, und eine Spalte, die den Rank in den Billboard Charts enthält. Um dies zu erreichen, nehmen wir alle Spalten, die mit "wk" beginnen, packen die Spaltennamen in eine neue Spalte namens `week` und die Werte aus den Spalten in die neue Spalte `rank`. Das Präfix "wk" aus den alten Spaltennamen können wir durch das Argument `names_prefix` ablegen. Und zuletzt löschen wir alle NA-Werte (NA steht für *not available*) -- es gibt z.B. keine Zeile für Woche 8 für 2Pac's "Baby Don't Cry", weil der Song in der achten Kalenderwoche nicht in den Top 100 gerankt wurde.

```{r}
billboard %>% 
  pivot_longer(cols = starts_with("wk"), 
               names_to = "week", 
               values_to = "rank",
               names_prefix = "wk",
               values_drop_na = TRUE)
```

Es gibt noch ein Gegenstück zu `pivot_longer()`, nämlich **`pivot_wider()`**. Diese Funktion wird deutlich seltener gebraucht, und bekommt vor allem die Argumente:

- `names_from`: die Spalte, deren einzigartige Werte als neue Spalten benutzt werden sollen
- `values_from`: die Spalte, deren Werte die neuen Spalten füllen sollen

Ein Beispiel dafür kann aus dem [Data Frame `us_rent_income`](https://tidyr.tidyverse.org/reference/us_rent_income.html) abgeleitet werden, der ebenfalls mit dem *tidyverse* geladen wird:

```{r}
us_rent_income
```

Wir möchten eine Spalte `income` und eine Spalte `rent` aus den Levels der Spalte `variable` erstellen und die neuen Spalten dann mit den Werten aus `estimate` füllen.

```{r}
us_rent_income %>% 
  pivot_wider(names_from = variable,
              values_from = estimate)
```

Im Ergebnis sehen wir jetzt aber einige `NA`-Werte. Diese können wir zum Beispiel durch Nullen ersetzen, indem wir zusätzlich das Argument `values_fill` verwenden.

```{r}
us_rent_income %>% 
  pivot_wider(names_from = variable,
              values_from = estimate,
              values_fill = 0)
```

Auch hier gibt es wieder komplexere Operationen, die `pivot_wider()` durchführen kann. Die beiden Hauptargumente `names_from` und `values_from` können jeweils auch mehr als eine Spalte angegeben bekommen. `pivot_wider()` erstellt dann so viele neue Spalten, wie es Kombinationen zwischen den Levels aus den originalen Spalten bzw. Spaltennamen gibt. Hier geben wir zum Beispiel die Spalten `estimate` und `moe` bei `values_from` an und erhalten so in Kombination mit den zwei Levels aus `variable` vier neue Spalten:

```{r}
us_rent_income %>% 
  pivot_wider(names_from = variable,
              values_from = c(estimate, moe))
```

Zuletzt noch ein phonetisches Beispiel: Wir möchten aus den Levels der Spalte `Bet` (Betonung) des Data Frames `asp` neue Spalten machen und diese mit den Dauerwerten `d` füllen. Der Code wirft aber eine Warnmeldung, weil es mehrere Werte pro Zelle gibt in den neuen Spalten gibt, wie Sie an der seltsamen Schreibweise sehen können:

```{r}
asp %>%
  pivot_wider(names_from = Bet,
              values_from = d)
```

Netterweise gibt uns die Warnmeldung auch sofort drei Lösungswege an: Wir können das Argument `values_fn` benutzen, um die Warnung zu unterdrücken, uns anzeigen zu lassen wie viele Werte pro Zelle es gibt, oder mit einer zusammenfassenden Funktion die Werte umformen. Letzteres scheint hier sinnvoll zu sein: Dort, wo es mehrere Werte pro Zelle gibt, lassen wir mit `mean()` den Durchschnitt berechnen:

```{r}
asp %>%
  pivot_wider(names_from = Bet,
              values_from = d,
              values_fn = mean)
```

In keinem unserer *pivoting*-Beispiele haben wir die Data Frames in ihrer veränderten Form überschrieben (z.B. mittels der Doppelpipe). Die Funktionen `pivot_longer()` und `pivot_wider()` kann man auch für temporäre Änderungen benutzen, z.B. wenn man den Data Frame in einer bestimmten Form nur für eine Abbildung braucht:

```{r}
avokal %>% 
  pivot_longer(cols = c(schnell, langsam), names_to = "Tempo", values_to = "Dauer") %>% 
  ggplot() +
  aes(x = Tempo, y = Dauer) + 
  geom_boxplot()
```

## Separating

Unser zweites Beispiel für *messy data* ist der Data Frame `vcv`, bei dem zwei Informationen in der Spalte `Context` vorhanden sind:

```{r}
vcv %>% head
```

Wir möchten den linken und rechten Kontext, die hier durch einen Punkt getrennt werden, in eigenen Spalten haben (wir entfernen zu Demonstrationszwecken die Spalten `Left` und `Right`, denn die enthalten schon die gewünschte Lösung).

```{r}
vcv %<>% 
  select(RT:Lang, Context) %>% 
  as_tibble()
```

Um unser Ziel zu erreichen, nutzen wir die Funktion **`separate()`**, die obligatorisch folgende Argumente bekommt:

- `col`: die Spalte, deren Inhalt aufgeteilt werden soll
- `into`: die neuen Spaltennamen
- `sep`: wie die *strings* in der gewählten Spalte getrennt werden sollen

Die ersten zwei Argumente sind eigentlich klar: `col` ist die Spalte `Context`, und bei `into` geben wir die zwei gewünschten Spaltennamen `Left` und `Right` an. Für `sep` gibt es zwei Optionen: Die erste Möglichkeit ist mittels einer Zahl, die den Index angibt, ab dem getrennt werden soll: wenn z.B. die ersten zwei Buchstaben immer in die eine und der Rest in die zweite Spalte geschrieben werden soll, nutzen wir `sep = 2`. Wenn wir uns aber die unterschiedlichen Werte in `Context` anschauen, ist das hier nicht sinnvoll:

```{r}
levels(vcv$Context)
```

Der linke Kontext kann aus einem oder zwei Buchstaben bestehen; außerdem ist da noch ein Punkt, der dann entweder in den linken oder rechten Kontext übernommen werden würde, wie man hier sieht:

```{r}
vcv %>% 
  separate(col = Context, 
           into = c("Left", "Right"), 
           sep = 1)
vcv %>% 
  separate(col = Context, 
           into = c("Left", "Right"), 
           sep = 2)
```

Die andere Möglichkeit ist eine **regular expression** (auch: regulärer Ausdruck oder RegEx). Dafür gibt man ein Muster (*pattern*) an, nach dem die Trennung in zwei Spalten erfolgen soll. Das würde für unser Beispiel gut passen, weil wir immer am Punkt trennen wollen. Der Punkt steht aber leider bei den regulären Ausdrücken für ein (und zwar egal welches) Schriftzeichen. Wenn wir den Punkt als Punkt verwenden wollen müssen wir ihn durch das Escape-Zeichen, den doppelten Backslash, schützen.

```{r}
vcv %>% 
  separate(col = Context, 
           into = c("Left", "Right"), 
           sep = "\\.")
```

So erreichen wir also das Ziel, dass jede Spalte nur eine Variable enthält!

<div class="gray">
**Weiterführende Infos: reguläre Ausdrücke**

RegExps sind ein komplexes Thema, in das wir hier nicht tiefer einsteigen werden. Wenn Sie sich einlesen wollen, empfehlen wir [Kapitel 14 aus *R for Data Science*](https://r4ds.had.co.nz/strings.html#matching-patterns-with-regular-expressions).
</div>

# Joining mit `dplyr`

Vielleicht kennen Sie von der Arbeit mit relationalen Daten(banken) und/oder SQL den sogenannten *join*. Das Prinzip relationaler Daten beruht darauf, alle Informationen und Messwerte, die man gesammelt und erhoben hat, in thematisch sinnvoll aufgeteilten Tabellen abzuspeichern. So könnte man nach einem Experiment zum Beispiel eine Tabelle mit den Messwerten (Formantwerte, Grundfrequenz, etc.) und eine Tabelle mit den Metadaten (Alter, Herkunft, Bildungsstand, etc.) zu den Sprechern erstellen. Zusätzlich bietet es sich vielleicht an, eine Tabelle mit Informationen über das erhobene Material (Wörter, Betonung, Phoneme, Stimuli, etc.) und über die getesteten Bedingungen (Sprechtempo, welcher Gesprächspartner, etc.) zu haben. Wenn nötig, kann man jederzeit (und ggf. nur temporär) zwei Tabellen über einen **key**, d.h. eine Identifikationsspalte, miteinander verbinden. Bei `dplyr` unterscheiden wir zwischen *mutating joins* und *filtering joins*.

## Mutating Joins

Wie auch bei `mutate()` werden einem Data Frame `x` durch einen *mutating join* weitere Spalten hinzugefügt. Im Gegensatz zu `mutate()` stammen die neuen Spalten aber aus einem anderen Data Frame `y`. In beiden Data Frames `x` und `y` muss es mindestens eine Spalte geben, die einen *identifier* oder *key* enthält, über den die Tabellen verbunden werden können.

### Inner Join

Die einfachste Form des *mutating join* ist der sogenannte *inner join*, der mittels der Funktion `inner_join()` durchgeführt wird. Die Funktion bekommt als Argumente zwei Data Frames `x` und `y` und den Identifier im Argument `by`. Das Ergebnis eines *inner join* enthält alle Spalten von `x` und `y` sowie alle Zeilen, für die es einen Match in beiden Data Frames gibt. Fehlende Werte (`NA`) tauchen **nicht** im Ergebnis eines *inner join* auf, daher ist hier immer Vorsicht angebracht.

Als einfaches Beispiel verwenden wir hier eine Tabelle mit Grundfrequenzwerten von zehn Sprechern und eine Tabelle mit Metadaten über die zehn Sprecher:

```{r}
measures <- tibble(subject = rep(paste0("s", 1:10), each = 10),
                   F0 = rnorm(100, 120, 15))
measures
meta <- tibble(subject = paste0("s", 1:10),
               age = rep(c("old", "young"), each = 5))
meta
```

Beide *tibbles* haben die Spalte `subject`, die wir als *key* bei unserem *inner join* benutzen werden:

```{r}
inner_join(x = measures, y = meta, by = "subject")
```

Es kann vorkommen, dass die *key*-Spalte in den zwei Data Frames unterschiedlich benannt ist. In diesem Fall sagen wir der Funktion mittels `by = c("a"="b")`, dass die Spalte `a` aus dem Data Frame `x` mit der Spalte `b` aus dem Data Frame `y` ge*matched* werden soll (das gilt für alle *join* Funktionen):

```{r}
measures %<>% rename(Vpn = subject)
inner_join(x = measures, y = meta, by = c("Vpn"="subject"))
measures %<>% rename(subject = Vpn)
```

In diesem Beispiel werden bislang immer alle Zeilen von `measures` zurückgegeben und alle Spalten beider Data Frames. Das liegt daran, dass es sowohl in `measures` als auch in `meta` Informationen zu denselben zehn Probanden gibt. Wenn wir in einem der Data Frames mehr oder weniger Informationen haben, werden plötzlich Zeilen weggelassen.

```{r}
# Messwerte von 20 statt 10 Sprechern:
measures <- tibble(subject = rep(paste0("s", 1:20), each = 10),
                   F0 = rnorm(200, 120, 15))
inner_join(x = measures, y = meta, by = "subject")
```

In diesem Ergebnis gibt es keine Zeilen für die Sprecher 11 bis 20, weil es zu diesen Sprechern keine Informationen im Data Frame `meta` gibt!

### Outer Join

Im Unterschied zum *inner join* werden beim *outer join* auch Zeilen mit fehlenden Werten beibehalten. Diese fehlenden Werte werden als `NA` gekennzeichnet. Die einfachste Version eines *outer join* ist der *full join*, bei dem alle Zeilen und alle Spalten aus beiden Data Frames beibehalten werden. Die entsprechende Funktion dazu heißt `full_join()` (wir frisieren das Ergebnis hier mit `slice()`, um einen interessanten Teil des Ergebnisses hervorzuheben):

```{r}
full_join(x = measures, y = meta, by = "subject") %>% 
  slice(95:105)
```

Dieses Ergebnis besteht aus 200 Zeilen (wenn wir nicht `slice()` darauf anwenden) -- als wir oben die Funktion `inner_join()` auf die exakt selben *tibbles* ausgeführt haben, hatte das Ergebnis nur 100 Zeilen. Das liegt daran, dass `full_join()` die 100 Zeilen mit den Messwerten der Sprecher 11 bis 20 beibehalten hat, während `inner_join()` diese Zeilen gelöscht hat, weil es für diese Sprecher keine Informationen aus `meta` zu holen gab. Beim Ergebnis des `full_join()` finden sich deshalb `NA`-Werte in der angehängten Spalte `age` für die Sprecher 11 bis 20.

Wenn Sie nicht alle Zeilen aus beiden Data Frames übernehmen wollen, stehen Ihnen die Funktionen `left_join()` und `right_join()` zur Verfügung. Beim `left_join()` werden alle Zeilen aus Data Frame `x` und beim `right_join()` alle Zeilen aus dem Data Frame `y` übernommen. In unserem Beispiel wollen wir alle Zeilen aus `measures` erhalten und nur die Altersinformation aus `meta` hinzufügen:

```{r}
left_join(x = measures, y = meta, by = "subject")
right_join(x = meta, y = measures, by = "subject")
```

## Filtering Joins

Die zweite Art von *joins* in R sind die sogenannten *filtering joins*, die keine neuen Spalten hinzufügen, sondern nur ausgewählte Zeilen zurückgeben. Hierfür gibt es im *tidyverse* zwei Funktionen:

- `semi_join()`: Gibt alle Beobachtungen des Data Frames `x` zurück, für die es einen Match im Data Frame `y` gibt
- `anti_join()`: Gibt alle Beobachtungen des Data Frames `x` zurück, für die es keinen Match im Data Frame `y` gibt

Wir werden diese beiden Funktionen anhand der folgenden Data Frames demonstrieren:

```{r}
vcv %<>% as_tibble()
vcv
vcv_summary <- vcv %>% 
  group_by(Subject, Vowel) %>% 
  summarise(mean_rt = mean(RT)) %>% 
  ungroup() %>%
  slice_max(mean_rt, n = 5)
vcv_summary
```

Der Data Frame `vcv_summary` enthält also die fünf höchsten durchschnittlichen Reaktionszeiten und welchem Sprecher und Vokal diese Werte zugeordnet sind. Wenn wir jetzt herausfinden wollen, aus welchen Beobachtungen in `vcv` diese Mittelwerte berechnet wurden, nutzen wir den *semi join*. Genau genommen möchten wir alle Zeilen aus `vcv` zurückbekommen, für die es in `vcv_summary` einen Match bezüglich der Spalten `Subject` und `Vowel` gibt.

```{r}
semi_join(x = vcv, y = vcv_summary, by = c("Subject", "Vowel"))
```

Das Ergebnis enthält jetzt also alle Beobachtungen, aus denen die gemittelten Reaktionszeiten in `vcv_summary` berechnet wurden. Wir können das nochmal verdeutlichen, indem wir uns ausgeben lassen, welche einzigartigen Kombinationen von `Subject` und `Vowel` es im Ergebnis des *semi joins* gibt (es sind dieselben fünf Kombinationen wie in `vcv_summary`):

```{r}
semi_join(x = vcv, y = vcv_summary, by = c("Subject", "Vowel")) %>% 
  select(Subject, Vowel) %>% 
  unique()
```

Mit dem *anti join* erhalten wir hingegen alle Beobachtungen, aus denen *nicht* die gemittelten Reaktionszeiten berechnet wurden, oder mit anderen Worten: alle Beobachtungen aus `vcv`, für die es bzgl. `Subject` und `Vowel` keinen Match in `vcv_summary` gibt.

```{r}
anti_join(x = vcv, y = vcv_summary, by = c("Subject", "Vowel"))
```

*Anti joins* eignen sich unter anderem zur Fehlersuche in den eigenen Daten. Nehmen wir nochmal unsere Beispieldaten von vorhin, `measures` mit Messwerten für 20 Sprecher, und `meta` mit Metadaten für nur 10 dieser Sprecher. Wenn wir den *anti join* hier anwenden, finden wir sofort heraus, für welche Zeilen in `measures` es keinen Match in `meta` gibt, für welche Sprecher es also keine Metadaten gibt.

```{r}
anti_join(x = measures, y = meta, by = "subject")
```

Das Ergebnis ist das Gegenstück zum *inner join* von oben: Wir erhalten hier die 100 Beobachtungen für die Sprecher 11 bis 20, für die es *keine* Metadaten gibt.

<div class="gray">
**Weiterführende Infos: `dplyr`**

Die *joins* waren die letzten Funktionen aus dem *tidyverse*, die wir Ihnen hier vorstellen wollen. Eine Übersicht über alle bisher gelernten und weitere Funktionen erhalten Sie in diesem [Cheatsheet](https://raw.githubusercontent.com/rstudio/cheatsheets/master/data-transformation.pdf).
</div>

# Pretty Plots

`ggplot2` bietet Ihnen vielfältige Möglichkeiten, Ihre Abbildungen zu verschönern und zu individualisieren. Hier stellen wir Ihnen die wichtigsten Spezifikationen vor.

## Achsenbeschriftungen

Die Beschriftungen der Achsen wird mit `xlab()` bzw. `ylab()` erstellt. Einen Titel können Sie mit `ggtitle()` hinzufügen:

```{r}
ggplot(asp) + 
  aes(x = Kons, y = d) + 
  geom_boxplot() + 
  xlab("Artikulationsstelle") + 
  ylab("Dauer (ms)") + 
  ggtitle("Boxplot-Daten")
```

Ansonsten können Sie auch `labs()` nutzen für alle Labels zusammen:

```{r}
ggplot(coronal) + 
  aes(x = Region, fill = Fr) + 
  geom_bar(position = "fill") + 
  labs(x = "Region", 
       y = "Proportion", 
       title = "Proportionale Aufteilung von Frikativen",
       subtitle = "Aufgeteilt nach Region")
```

## Koordinatensystem begrenzen

Um den sichtbaren Bereich eines Plots zu begrenzen oder zu erweitern, können Sie die folgenden Funktionen verwenden. Diese haben jedoch unterschiedliche "Nebenwirkungen" (s. auch [hier](https://ggplot2.tidyverse.org/reference/coord_cartesian.html)):

* `xlim()` und/oder `ylim()` bzw. `scale_x_continuous(limits = c())` und/oder `scale_y_continuous(limits = c())`: Eliminiert Datenpunkte beim Heranzoomen und wirft eine Warnmeldung. Dies beeinflusst ggf. Regressionslinien und andere überlagerte Abbildungskomponenten.
* `coord_cartesian(xlim = c(), ylim = c())`: Blendet die Datenpunkte nur aus und wirft daher keine Warnmeldung. Dies beeinflusst Regressionslinien und andere überlagerte Abbildungskomponenten nicht.

```{r}
# ohne Achsenbeschränkung:
ggplot(int) + 
  aes(x = dB, y = Dauer) + 
  geom_point()

# mit coord_cartesian()
ggplot(int) + 
  aes(x = dB, y = Dauer) + 
  geom_point() + 
  coord_cartesian(xlim = c(10,40), 
                  ylim = c(30,280))

# mit xlim() und ylim()
ggplot(int) + 
  aes(x = dB, y = Dauer) + 
  geom_point() + 
  xlim(10, 40) + 
  ylim(30, 280)
```

## Farben

`ggplot2` verwendet standardmäßig immer dieselbe Farbpalette. Ihnen stehen aber deutlich mehr Farben zur Verfügung, wie Ihnen diese [Farbauswahl](http://www.stat.columbia.edu/~tzheng/files/Rcolor.pdf) zeigt. Die Farbnamen bekommen Sie auch mit:

```{r, eval = F}
colors()
```

```{r}
# die ersten 10 anzeigen:
colors()[1:10]
```

Ihre Farbauswahl teilen Sie mit den Argumenten `col` (Umriss- bzw. Linienfarbe) bzw. `fill` (Füllfarbe) im *aesthetic mapping* mit. Wenn wir die Variable `Kons` in folgendem Boxplot farb-kodieren wollen, sieht das so aus:

```{r}
# mit "fill" (empfohlen für Boxplots!)
ggplot(asp) + 
  aes(x = Kons, y = d, fill = Kons) + 
  geom_boxplot()

# mit "col"
ggplot(asp) + 
  aes(x = Kons, y = d, col = Kons) + 
  geom_boxplot()
```

Wie Sie sehen, wurde diesen zwei Plots automatisch eine Legende hinzugefügt, die aufschlüsselt, welche Farben für welche Werte der Variable `Kons` verwendet wurden. Jetzt wollen wir unsere Farben selbst auswählen:

```{r}
# "fill" mit eigenen Farben
farben <- c("darkgoldenrod1", "navy")
ggplot(asp) + 
  aes(y = d, x = Kons, fill = Kons) + 
  geom_boxplot(fill = farben)
```

Hier gibt es keine Legende. Wenn wir bei selbst gewählten Farben eine Legende haben wollen, benutzen wir eine Funktion namens `scale_color_manual()` bzw. `scale_fill_manual()`:

```{r}
# "fill" mit eigenen Farben
farben <- c("darkgoldenrod1", "navy")
ggplot(asp) + 
  aes(y = d, x = Kons, fill = Kons) + 
  geom_boxplot() + 
  scale_fill_manual(values = farben)

# dasselbe für den Barplot
ggplot(coronal) + 
  aes(x = Region, fill = Fr) + 
  geom_bar() + 
  scale_fill_manual(values = farben)
```

Für Boxplots gibt es übrigens die Möglichkeit, die Outlier uabhängig von der Box zu gestalten:

```{r}
farben <- c("darkgoldenrod1", "navy")
ggplot(asp) + 
  aes(y = d, x = Kons, fill = Bet) + 
  geom_boxplot(outlier.color = "red", 
               outlier.shape = 4, 
               outlier.size = 3) + 
  scale_fill_manual(values = farben)
```

## Weitere Spezifikationen

Es gibt natürlich noch deutlich mehr Spezifikationen für die einzelnen Abbildungstypen als die Farbe, z.B. die Zeichengröße, den Linientyp, die Punktform, die Schriftart... 

* `col`: Umriss- bzw. Linienfarbe
* `fill`: Füllfarbe
* `shape`: Form
* `size`: Größe
* `lty`: Linientyp
* `stroke`: Dicke für Text

Dazu gibt es eine Vignette:

```{r, eval = F}
vignette("ggplot2-specs")
```

Einige dieser Spezifikationen wenden wir hier an:

```{r}
ggplot(int) + 
  aes(x = dB, y = Dauer) +
  geom_point(col = "purple", 
             size = 3, 
             shape = 0) + 
  geom_line(col = "orange", 
            size = 1.5, 
            lty = "twodash")
```

Sie sollten sich aber natürlich immer sorgfältig überlegen, ob eine Spezifikation notwendig ist, um die Abbildung klarer zu gestalten.

## Schriftzeichengröße

Die Default-Schriftzeichengröße der Achsenbeschriftung und Titel ist 11pt oder kleiner. Vor allem wenn Sie Ihre Plots präsentieren, ist es SEHR wichtig, dass Sie die Schriftzeichengröße verändern. Wir empfehlen **mind. 16-24pt**. Hierfür müssen wir das `theme()` ändern.

```{r}
ggplot(asp) + 
  aes(x = Kons, y = d) + 
  geom_boxplot() + 
  xlab("Artikulationsstelle") + 
  ylab("Dauer (ms)") + 
  ggtitle("Boxplot-Daten") + 
  theme(text = element_text(size = 24),            # Beschriftungen & Titel
        axis.text = element_text(size = 18))       # Achsenbeschriftungen
```

<div class="gray">
**Weiterführende Infos: theme()**

Das `theme()` ist z.B. für die Hintergrundfarbe der Plots, die Achsen, und vieles weitere zuständig. Diese [Übersicht an Argumenten](https://ggplot2.tidyverse.org/reference/theme.html) der Funktion `theme()` zeigt Ihnen, wie viel Sie damit einstellen können.
</div>

## Plots unterteilen und anordnen

### Plots unterteilen

`ggplot2` bietet zwei Möglichkeiten, einen Plot in mehrere zu unterteilen: `facet_wrap()` und `facet_grid()`. Hauptargument dieser Funktionen ist/sind die üblicherweise kategoriale(n) Variable(n), deren Werte in getrennten Panels dargestellt werden sollen. Zum Beispiel können wir die Datenpunkte, die mit unterschiedlichen Phonemen assoziiert sind, in getrennten Panels darstellen.

Die Formeln, um die Variablen anzugeben, sehen wie folgt aus:

* `.~Var1` bzw. `~Var1`
* `Var1~.` (Punkt muss da sein!)
* `Var1~Var2`
* `Var1+Var2~Var3`
* `Var1~Var2+Var3`

Es bietet sich nicht an, mehr als drei Variablen in `facet_wrap()` oder `facet_grid()` zu verwenden, da dies die Übersichtlichkeit des Plots deutlich einschränkt.

`facet_wrap()` ordnet die Panels eines Plots in Reihen *und* Spalten an.

```{r}
# aufteilen nach Versuchsperson
ggplot(vdata) + 
  aes(x = F1, y = F2) + 
  geom_point() + 
  facet_wrap(~Subj)

# aufteilen nach Versuchsperson und Gespanntheit
ggplot(vdata) + 
  aes(x = F1, y = F2) + 
  geom_point() + 
  facet_wrap(Subj~Tense)
```

`facet_grid()` hingegen ordnet in Zeilen *oder* Spalten. Die Reihenfolge für die Formel ist `facet_grid(Zeilen~Spalten)`

```{r}
# aufteilen nach Versuchsperson in Zeilen
ggplot(vdata) + 
  aes(x = F1, y = F2) + 
  geom_point() + 
  facet_grid(Subj~.)

# aufteilen nach Versuchsperson in Spalten
ggplot(vdata) + 
  aes(x = F1, y = F2) + 
  geom_point() + 
  facet_grid(~Subj)

# aufteilen nach Versuchsperson und Tense
ggplot(vdata) + 
  aes(x = F1, y = F2) + 
  geom_point() + 
  facet_grid(Subj~Tense)
```

### Plots anordnen

Des Weiteren gibt es die Möglichkeit, mehrere Plots neben- oder untereinander anzuordnen. Hierfür verwenden wir die Funktion `grid.arrange()` die oben geladene Library `gridExtra`.

```{r}
plot1 <- ggplot(asp) +
  aes(x = Kons, y = d) +
  geom_boxplot()

plot2 <- ggplot(coronal) + 
  aes(x = Region, fill = Fr) + 
  geom_bar()

plot3 <- ggplot(int) +
  aes(x = dB, y = Dauer) +
  geom_line() + geom_point()

# in drei Spalten und einer Zeile anordnen
grid.arrange(plot1, plot2, plot3, ncol = 3, nrow = 1)

# in einer Spalte und drei Zeilen anordnen
grid.arrange(plot1, plot2, plot3, ncol = 1, nrow = 3)
```

# Hilfe zur Selbsthilfe

`ggplot2` ist nicht nur bekannt, sondern auch beliebt! Dementsprechend viel Hilfe bekommen Sie von der R Community. Hier ein paar gute Quellen für Hilfe bei der Erstellung von Abbildungen:

- Kapitel [Data Visualisation](https://r4ds.had.co.nz/data-visualisation.html) in Hadley Wickham's "R for Data Science"

- [Cookbook for R](http://www.cookbook-r.com/Graphs/)

- [Cheatsheet ggplot2](https://rstudio.com/wp-content/uploads/2015/03/ggplot2-cheatsheet.pdf)

- [Stack Overflow](https://stackoverflow.com/questions/tagged/ggplot2?sort=faq)
