---
title: "ADA Bayern"
subtitle: "Modul 2: Einfache Zufallsstichprobe"
format:
  html:
    toc: true
    number-sections: true
    highlight-style: github
    embed-resources: true
    df-print: paged
editor: visual
---

## Ziel des Notebooks

In diesem Notebook lernen wir eine einfache Zufallsstichprobe zu ziehen. Das Ziel ist es dieses Wissen für das Projekt zu nutzen.

**Zur Anonymisierung wurde dieses File nachträglich verändert!**

## Software-Pakete laden

Zunächst laden wir einige R-Pakete, die uns bei der Analyse helfen.

R-Pakete sind Erweiterungen, Sammlungen von nützlichem Code die im CRAN (Comprehensive R Archive Network) zur Verfügung gestellt werden.

In diesem Modul nutzen wir das sogenannte tidyverse[^1], das viele nützliche und einfach verständliche (tidy!) Funktionen zum Arbeiten mit Datensätzen bereitstellt.

[^1]: Wickham H, Bryan J (2022). *readxl: Read Excel Files*. R package version 1.4.0, https://CRAN.R-project.org/package=readxl.

Das survey[^2] Paket hilft uns später bei der Stichprobenziehung. Das Paket stellt viele nützliche Funktionen für die Analyse von Daten aus Stichproben bereit.

[^2]: Lumley T (2010). Complex Surveys: A Guide to Analysis Using R: A Guide to Analysis Using R. John Wiley and Sons.

Das PracTools[^3] Paket beeinhaltet weitere nützliche Funktionen zur Analyse komplexerer Stichprobendesigns.

[^3]: Valliant, R., Dever, J., Kreuter, F. (2018). Practical Tools for Designing and Weighting Survey Samples, 2nd edition. New York: Springer.

Wir haben die Pakete bereits alle in der Arbeitsumgebung installiert[^4]. Installierte Pakete können dann mit der Funktion `library()` für unser Notebook verfügbar gemacht werden.

[^4]: Falls Sie auf Ihrem eigenen Rechner ein neues Paket installieren wollen, können Sie das mit der Funktion `install.packages()`. Im Funktionsaufruf müssen Sie dann nur den Paketnamen angeben. Wenn Sie also, zum Beispiel, das Paket `PracTools` installieren wollen, lautet der Funktionsaufruf: `install.packages("PracTools")`.

```{r}
library("tidyverse")
library("survey")
library("PracTools")
library("sf")
```

## Einlesen der Daten

In diesem Schritt lesen wir die Daten in R ein[^5].

[^5]: Die Forumstar Daten liegen uns in einer `.csv` Datei vor. Diese können wir mit der Funktion `read_csv` einlesen. Zunächst definieren wir den Pfad zum Ordner mit den Daten im Objekt `pfad`, dafür nutzen wir die Funktion `file.path()`, dort geben wir Schritt für Schritt den Weg zum Ordner mit den Daten an. Dann definieren wir dafür die verschiedenen Datentypen in jeder Spalte. Ein `c` steht für character, also Textdaten, wie zum Beispiel in Namensfeldern. `n` steht für numerische Werte, `T` steht für eine Datumsangabe mit Uhrzeit (von "Time"). Diese Informationen speichern wir im Objekt `col_types`. Anschließend lesen wir den Datensatz mit der Funktion `read_csv()` direkt aus dem Ordner in unserer sicheren Datenumgebung ein. Wir können die Daten dann später über das Objekt `forumstar_daten` aufrufen.

    Wir lesen die Kartendaten ebenfalls gleich ein.

```{r}
pfad <- file.path(".")
col_types <- c("ccccnccccccccccccccccccTTcnTccnTcTcccc")

forumstar_daten <- read_csv(file.path(pfad, "230817_Abfrage_Januar-Dezember.csv"), col_types = col_types)
karte_amtsgerichte <- readRDS(file.path(pfad, "230911_Karte_Amtsgerichtsbezirke.RDS"))
```

## Daten für die Stichprobenziehung vorbereiten

Für die Stichprobenziehung benötigen wir nicht alle Spalten des Datensatzes. Auch brauchen wir nur einen einzigen Eintrag pro Akte. Die beteiligten Personen interessieren uns hier zunächst nicht. Daher bereiten wir die Daten zunächst vor.

Mit dem folgenden Code aggregieren wir die Daten auf einen Eintrag pro Aktenzeichen[^6].

[^6]: Dazu verwenden wir die `group_by` Funktion. Zusätzlich erstellen wir mithilfe der Funktion `summarise()`eine neue Spalte `Anzahl Beteiligte`. Anschließend fügen wir noch eine eindeutige Index Spalte `Index` für jede Akte hinzu.

```{r}
akten <- forumstar_daten %>%
  group_by(
    `Gericht`,
    `Aktenzeichen`,
    `Streitwert in EURO`,
    `Gesamtstreitgegenstand`,
    `Erledigungsgrund`,
    `Dauer des Verfahrens in Tagen`,
    `Archivstatus`,
    `Anbietungsgrund (manuell erfasst)`,
    `Anbietungsgrund`
  ) %>%
  summarise(`Anzahl Beteiligte` = n()) %>%
  as.data.frame() %>%
  mutate(Index = row_number())
```

Um unsere visuelle Darstellung auf Karten zu ermöglichen generieren wir außerdem die Spalte Bezirk und fügen sie unserem Datensatz hinzu.

```{r}
tmp_Gericht <- sub("Amtsgericht ", "", akten$Gericht)
tmp_Gericht <- sub(" Zweigstelle.*", "", tmp_Gericht)
tmp_Gericht <- sub(" i.d. ", " i. d. ", tmp_Gericht)
tmp_Gericht <- sub(" a.d. ", " a. d. ", tmp_Gericht)
tmp_Gericht <- sub(" am ", " a. ", tmp_Gericht)
tmp_Gericht <- sub(" i.OB", " i. OB", tmp_Gericht)

akten <- akten %>%
  mutate(`Bezirk` = tmp_Gericht)
```

## Ziehung einer einfachen Zufallsstichprobe

Für die Ziehung einer einfachen Zufallsstichprobe benötigen wir eine wohl definierte Grundgesamtheit. In unserem Fall bilden alle Akten aus dem Jahr 2018 (alle bayerischen Amtsgerichte, nur Registerzeichen C) die Grundgesamtheit. Der Umfang der Grundgesamtheit, hier die Anzahl aller Akten in einem Jahr, wird mit $N$ bezeichnet.

Außerdem benötigen wir die Stichprobengröße, also die Anzahl der Akten die ausgewählt werden sollen. Die Stichprobengröße wird mit $n$ bezeichnet.

Im folgenden Code lesen wir zunächst die Anzahl der Akten aus[^7].

[^7]: Wir nutzen dafür `nrow()` Funktion um die Anzahl (`n`) der Zeilen (`row`) im Datensatz `akten` zählen.

```{r}
N <- akten %>% 
  nrow()

N
```

Dann legen wir den Stichprobenumfang $n$ auf 200 fest[^8].

[^8]: Wir generieren ein neues Objekt `n` dem wir den Wert 200 zuweisen.

```{r}
n <- 200
n
```

Als Auswahlwahrscheinlichkeit bezeichnet man die Wahrscheinlichkeit, mit der eine Einheit (hier eine Akte, technisch eine Zeile) in die Stichprobe gelangt[^9].

[^9]: Dafür berechnen wir den Quotienten $n$/$N$ und multiplizieren in mit 100 um Prozentangaben zu bekommen.

```{r}
100 * n/N
```

**Mit welcher Wahrscheinlichkeit (in Prozent) wird eine Akte ausgewählt?**

Nun können wir eine einfache Zufallsstichprobe ziehen[^10]. Als Ergebnis erhalten wir $n=200$ zufällig gewählte Werte aus der Spalte Index.

[^10]: Dafür verwenden wir die Funktion `sample()` (das englische "to draw a sample" bedeutet "eine Stichprobe ziehen"). Wir nehmen die Einträge in der Index Spalte und ziehen eine Zufallsstichprobe mit der Stichprobengröße $n$ (`size = n`) ohne Zurücklegen (`replace = FALSE`).

```{r}
Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
Index_stichprobe
```

Wenn wir den gleichen Code noch einmal ausführen, bekommen wir eine neue Zufallsstichprobe.

```{r}
Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
Index_stichprobe
```

------------------------------------------------------------------------

### Exkurs: Startwerte für den Zufallszahlengenerator setzen

Um die Ziehung reproduzierbar zu machen, können wir auch einen Startwert für den Zufallszahlengenerator setzen[^11].

[^11]: Dafür nutzen wir die Funktion `set.seed()`.

```{r}
set.seed(20230919)
Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
Index_stichprobe
```

Wenn wir den selben Startwert setzen, erhalten wir jetzt jedes Mal dieselbe Stichprobe.

```{r}
set.seed(20230919)
Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
Index_stichprobe
```

------------------------------------------------------------------------

Mit den Indizes in der Stichprobe können wir nun die entsprechenden Zeilen in unserem Datensatz `akten` auswählen. Das machen wir über einen einfachen Abgleich der Indizes[^12].

[^12]: Mit `akten$Index %in% Index_stichprobe` wird einzeln für jede Zeile (`akten$Index`) überprüft, ob diese Zeile in (Operator `%in%`) der gezogenen Stichprobe (`Index_stichprobe`) ist. Mithilfe der eckigen Klammern (`akten[c(TRUE, FALSE, …, FALSE),]`) werden nur diejenigen Zeilen aus der `akten`-Tabelle zurückgegeben, wo dies der Fall ist. Das Ergebnis der Auswahl sind die 200 Akten in unserer Stichprobe.

```{r}
akten_stichprobe <- akten[akten$Index %in% Index_stichprobe, ]
```

### Wie groß sollte unsere Stichprobe sein?

Als einfache Regel gilt, je größer die Stichprobe, desto genauer können wir die Grundgesamtheit abbilden.

Was bedeutet "genau"? Jede Wiederholung der Stichprobenziehung ergibt eine neue Stichprobe. Das heißt, die Akten, die Teil der Stichprobe sind, unterscheiden sich von Wiederholung zu Wiederholung. Berechnen wir nun, zum Beispiel, einen Mittelwert auf Grundlage der Stichprobe, unterscheiden sich die Ergebnisse der Berechnung. Je größer die Stichprobe ist, desto kleiner werden die Unterschiede und desto näher wird (in der Regel) das Stichprobenmittel dem Mittelwert aus der Grundgesamtheit kommen.

### Beispiel zur Stichprobengröße

Hier berechnen wir den mittleren Streitwert (auch Median genannt), um den in unserer Grundgesamtheit üblicherweise gestritten wird [^13].

[^13]: Wir berechnen den Median mit der Funktion `median()` . `na.rm = TRUE` gibt an, dass Akten bei der Berechnung ignoriert werden, wenn dort kein Wert angegeben ist. Andernfalls können wir keine Berechnung durchführen.

```{r}
round(median(akten$`Streitwert in EURO`, na.rm = TRUE))
```

Dies ist der wahre Wert aus der Grundgesamtheit, an dem üblicherweise Interesse besteht. Idealerweise könnte man alle Akten aufbewahren und so diesen Mittelwert (oder beliebige andere Maße) jederzeit neu berechnen.

Allerdings kann nur eine Stichprobe gezogen/archiviert werden. Der mittlere Wert in der Stichprobe wird nur ungefähr dem Wert in der Grundgesamtheit entsprechen[^14].

[^14]: Der hier verwendete Code wurde im Detail bereits oben vorgestellt.

```{r}
n <- 200
set.seed(20230919)
Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
akten_stichprobe <- akten[akten$Index %in% Index_stichprobe, ]
round(median(akten_stichprobe$`Streitwert in EURO`, na.rm=TRUE))

```

Mit einer anderen Stichprobe erhalten wir einen anderen Wert.

```{r}
Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
akten_stichprobe <- akten[akten$Index %in% Index_stichprobe, ]
round(median(akten_stichprobe$`Streitwert in EURO`, na.rm=TRUE))
```

Wenn wir dies nun sehr oft (zum Beispiel 1000 mal) durchführen, können wir betrachten, wie genau wir den mittleren Wert aus unseren Stichproben schätzen[^15].

[^15]: Mit der Funktion `sapply()` wenden wir eine Funktion wiederholt, hier über den Vektor der Zahlen von 1 bis 1000 (1:1000) an. Die Funktion die wir anwenden sind die drei Schritte aus den vorherigen Beispielen um eine Stichprobe mit Umfang $n$ = 200 zu ziehen.

```{r}
verteilung_200 <- sapply(1:1000, function(x) {
  Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
  akten_stichprobe <- akten[akten$Index %in% Index_stichprobe,]
  round(median(akten_stichprobe$`Streitwert in EURO`, na.rm = TRUE))
})
```

Diese Verteilung können wir dann visuell in einem sogenannten Histogram darstellen[^16].

[^16]: Dafür nutzen wir die Funktion ggplot. Zunächst müssen wir unsere Verteilung als `data.frame` an die Funktion übergeben, dabei benennen wir die Spalte Median. Diese Spalte lassen wir uns dann anzeigen. Mit geom_histogram() definieren wir, dass wir ein Histogram erstellen möchten. theme_minimal() verändert das Aussehen der visuellen Darstellung. (Sie können gerne ausprobieren, was ohne theme_minimal() passiert.)

```{r}
ggplot(data.frame(Median = verteilung_200), aes(x = Median)) + 
  geom_histogram() + 
  theme_minimal()
```

Zum Vergleich ziehen wir nun zunächst *zwei* einfache Zufallsstichproben mit dem Stichprobenumfang $n = 1000$.

```{r}
n <- 1000
set.seed(20230919)
Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
akten_stichprobe <- akten[akten$Index %in% Index_stichprobe, ]
round(median(akten_stichprobe$`Streitwert in EURO`, na.rm=TRUE))
```

```{r}
Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
akten_stichprobe <- akten[akten$Index %in% Index_stichprobe, ]
round(median(akten_stichprobe$`Streitwert in EURO`, na.rm=TRUE))
```

Dann wiederholen wir den Prozess wieder 1000 mal.

```{r}
verteilung_1000 <- sapply(1:1000, function(x) {
  Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)
  akten_stichprobe <- akten[akten$Index %in% Index_stichprobe,]
  round(median(akten_stichprobe$`Streitwert in EURO`, na.rm = TRUE))
})
```

Diese Verteilung können wir dann visuell in einem sogenannten Histogram darstellen.

```{r}
ggplot(data.frame(Median = verteilung_1000), aes(x = Median)) + 
  geom_histogram() + 
  theme_minimal()
```

Wie erwartet sind die geschätzten Werte in den größeren Stichproben deutlich näher am Median der Grundgesamtheit (1134) als in den kleineren Stichproben. Eine größere Stichprobe führt zu verbesserter Genauigkeit.

### Graphische Darstellung

Nun wollen wir die einfache Zufallsstichprobe vergleichen, mit dem was aktuell angeboten wird. Dazu betrachten wir den Anteil angebotener Akten pro Gericht und stellen dies dar. Berechne zunächst die Anteile.

```{r}
anteil_anzubietend <- akten %>%
  mutate(AkteAnzubieten = case_when(
    `Archivstatus` == "anzubieten" ~ "Ja",
    is.na(`Archivstatus`) ~ "Nein",
    TRUE ~ "Nein")) %>%
  group_by(`Bezirk`, `AkteAnzubieten`, .drop = FALSE) %>%
  summarise(n = n()) %>%
  mutate(anteil = n / sum(n)) %>%
  filter(`AkteAnzubieten` == "Ja")

anteil_anzubietend
```

Nun stellen wir die Anteile auf einer Karte dar.

```{r}
# In Karte übernehmen
karte_amtsgerichte$`Anzubietende Akten` <- anteil_anzubietend$anteil[match(karte_amtsgerichte$court, anteil_anzubietend$Bezirk)]
karte_amtsgerichte$`Anzubietende Akten`[karte_amtsgerichte$`Anzubietende Akten` == 0] <- NA

# und Plotten
ggplot(data = karte_amtsgerichte, aes(fill = `Anzubietende Akten`)) +
  geom_sf(aes(geometry = geometry), color = "transparent") +
  geom_sf_text(
    aes(geometry = geometry, label = court),
    size = 1.5,
    col = "black",
    fun.geometry = function(x)
      st_centroid(x)
  ) +
  scale_fill_viridis_b(option = "viridis") +
  theme_void()
```

Schweinfurt und Kitzingen bieten einen besonders hohen Anteil an, mehr als 3 Prozent! Von vielen Gerichten wird aber auch keine einzige Akte angeboten.

**Woran liegt diese ungleiche Verteilung?**

Nun sollen $n = 372$ Akten (so viele wie 2018 angeboten wurden) zufällig gezogen werden. In dem Indikator `inSample` in `akten_kopie` wird abgespeichert, ob die Akte gezogen wurde oder nicht.

```{r}
n <- 372
set.seed(20230919)
Index_stichprobe <- sample(akten$Index, size = n, replace = FALSE)

akten_kopie <- akten
akten_kopie$inSample[akten$Index %in% Index_stichprobe] <- "Ja"
```

Berechne die Anteile der zufällig ausgewählten Akten in jedem Bezirk.

```{r}
anteil_anzubietend_zufaellig <- akten_kopie %>%
  mutate(AkteAnzubieten = case_when(
    `inSample` == "Ja" ~ "Ja",
    is.na(`inSample`) ~ "Nein",
    TRUE ~ "Nein")) %>%
  group_by(`Bezirk`, `AkteAnzubieten`, .drop = FALSE) %>%
  summarise(n = n()) %>%
  mutate(anteil = n / sum(n)) %>%
  filter(`AkteAnzubieten` == "Ja")

anteil_anzubietend_zufaellig
```

Auf einer Karte können wir nun erneut darstellen, wie viele Akten angeboten werden wenn dies rein zufällig erfolgen würde.

```{r}
# in Karte übernehmen
karte_amtsgerichte$`Anzubietende Akten` <- anteil_anzubietend_zufaellig$anteil[match(karte_amtsgerichte$court, anteil_anzubietend_zufaellig$Bezirk)]
karte_amtsgerichte$`Anzubietende Akten`[karte_amtsgerichte$`Anzubietende Akten` == 0] <- NA

# und plotten
ggplot(data = karte_amtsgerichte, aes(fill = `Anzubietende Akten`)) +
  geom_sf(aes(geometry = geometry), color = "transparent") +
  geom_sf_text(
    aes(geometry = geometry, label = court),
    size = 1.5,
    col = "black",
    fun.geometry = function(x)
      st_centroid(x)
  ) +
  scale_fill_viridis_b(option = "viridis") +
  theme_void()

```

Die meisten Gerichte würden bei zufälliger Auswahl mindestens eine Akte anbieten. Man beachte aber auch die Skala: Es ist höchst unwahrscheinlich, dass ein Gericht auch nur 1% seiner Akten zur Archivierung anbieten würde.

## Diskussion: Was muss berücksichtigt werden? Was sind Vor- und Nachteile einer einfachen Zufallsstichprobe?

1.  Welche Faktoren beeinflussen, wie groß die Stichprobe sein kann?
2.  Als Grundgesamtheit wurde hier "alle C-Verfahren in einem Jahr in Bayern" verwendet. Ist dies so sinnvoll und praktikabel oder gibt es bessere Alternativen?
3.  Ist die einfache Zufallsstichprobe zur Auswahl von Akten geeignet? Welche Vor- und Nachteile hat das Verfahren?

#### Vorteile

-   keine systematische Auswahl von Akten (z.B. anhand von Nachnamen)
-   Repräsentative Stichprobe
-   Alle Akten haben dieselbe Auswahlwahrscheinlichkeit

#### Nachteile

-   Nicht alle Gerichte/Landkreise/Regionen tauchen immer in der Stichprobe auf
-   Alle Akten haben dieselbe Auswahlwahrscheinlichkeit
