---
# System prepended metadata

title: Vorlesung "Datenanalyse in der Biologie"

---

---
title: Vorlesung "Datenanalyse in der Biologie"
author: Simon Anders
---

## Vorlesung "Datenanalyse in der Biologie"

Simon Anders
Winter-Semester 2020/21

## 1. Vorlesung (2020-11-09)

### Worum geht es in dieser Vorlesung?

Woher kommen Daten in der Biologie?

- eigene Experiment: 
  - kleine Experimente: Aufzeichnungen im Laborbuch oder in Spreadsheets
  - Hochdurchsatz-Experimente: größere Dateien
  - Mikroskopie und bildgebende Verfahren: Bilddateien
- aus veröffentlichten Experimenten
- aus gesammelten und aufbereiteten Daten (Datenbanken und andere curated resources)

Was wollen wir erreichen?

Grundaufgabe: großer Haufen Daten --> interessantes wissenschaftliches Ergebnis

Stadien/Aspekte eines Projekts
- Experimente
- Aufzeichnen und Zusammenstellen der Daten
- Daten-Aufbereitung (data preprocessing)
    - Daten-Formate vereinheitlichen
    - Daten säubern (data cleansing)
    - Qualitätskontrolle (quality assessment)
- Daten-Analyse:
    - Zusammenfassen (summerization)
    - Visualisierung (data visualization, plotting)
    - Modellierung (modelling)
- Interpretation
- Aufstellen von Hypothesen (hypothesis generation) oder Schlußfolgerungen (conclusions)
- Validierung (validation)
- Dokumentation (documentation)
- Archivierung (archiving)
- Veröffentlichung (publication)

**Wichtig**: Dies ist kein linearer Prozess: Vielmehr bewegt man sich oft im Kreis (oder eher: in einer Spirale).


Welche Werkzeuge verwenden wir in der Datenanalyse?
- Papier und Bleistift
- Tabellenkalkulationsprogramme (spread sheets) wie Microsoft Excel
- Daten-Analyse-Programme wie GraphPad Prism oder Origin
- Spezial-Programmiersprachen für Statistik wie SAS, SPSS, oder R
- Universal-Programmiersprachen wir Python, C, C++ usw.


#### eine einfache Einführung ins Programmieren

Logo
- eine Programmiersprache für Kinder
- entwickelt 1967 von Wally Feurzeig, Seymour Papert, und Cynthia Solomon
- pädagogisches Konzept: Turtle-Grafik

#### Turtle-Grafik
- Man steuert eine Roboter-Schildkröte mit einfachen Befehlen
- Die Schildkröte kann mit einem Stift eine Spur hinterlassen
- Wir verwenden nicht Logo, sondern ein Turtle-Grafik-Erweiterung für R
- Somit lernen wir schon ein bisschen R, während wir geometrische Formen zeichnen

Turtle-Grafik: Erster Versuch
- Vorführung: Ich zeichne ein Quadrat.
- Ich habe die folgenden Befehle in die Konsole von RStudio eingegeben, Zeile für Zeile:
```
library( TurtleGraphics )
turtle_init()
turtle_forward( 10 )
turtle_right( 90 )
turtle_forward( 10 )
turtle_right( 90 )
turtle_forward( 10 )
turtle_right( 90 )
turtle_forward( 10 )
turtle_right( 90 )
```  
Die Schildkröte erscheint und zeichnet ein Quadrat.

Vorbereitung: Um diese Befehle eingeben zu können, fangen wir wie folgt an:
1. R installieren: https://cloud.r-project.org/
2. RStudio installieren: https://rstudio.com/
3. RStudio starten, wir finden links das fenster mit der Konsole
4. In der Konsole eingeben `install.packages("TurtleGraphics")`, um das TurtleGraphics-Paket zu installieren
5. Nun können wir die o.g. Befehle eintippen.

Jede Zeile ist ein Befehl an R. Zum Beispiel bedeutet `turtle_left( 90 )`, oder auch alternativ `turtle_turn( 90, "left" )`: Schildkröte, drehe dich 90 Grad nach links.

Wir betrachten das genauer:
  - `turtle_turn` ist der Funktionsname ("function name")
  - Dem folgt die Argumentliste ("argument list"). Sie ist immer in runde Klammern (parentheses, parens) eingeschlossen
  - Wenn die Argumentliste mehrere Argumente enthalten, werden sie durch Kommas (commas) getrennt
  - das erste Argument, vor dem Komma, ist hier der Winkel. Es muss immer eine Zahl sein
  - das zweite Argument ist bei `turtle_turn` die Richtung. Es muss immer ein Wort ("String") sein, entweder ``"left"`` oder ``"right"`.
  - Ein String (also ein Stück Text, eine "Zeichenkette") muss immer in Anführungszeichen stehen
  - Leerzeichen ignoriert R, also kann man sie setzen, wie man mag (aber nicht innerhalb von Anführungszeichen)
  - Aller Text nach einem Hash-Zeichen ("#") wird von R ignoriert. Damit kann man sich in seinem Programm Anmerkungen ("comments") machen
  - Mache Funktionen haben keine Argumente. Trotzdem bekommen sie eine Argumentliste, die dann leer ist, aber trotzdem nicht fehlen darf. Beispiel: turtle_init()

- DIe grafische Ausgabe erscheint im "plot panel", rechts unten

- Dort findet man auch die Hilfe (help), wo man zum Beispiel nachschlagen kann, welche "turtle"-Funktionen es gibt, und welche Argumente die erwarten

- Die Turtle-Grafik ist kein Teil von R, ist also nicht dabei, wenn man R installiert. Es ist ein Erweiterungs-Paket ("package"), dass man erst installieren muss. Dazu schreibt man in der Konsole einfach: `install.packacke( "TurtleGraphics")``
- Wenn man R startet, sind die installierten Pakete zunächst nicht aktiv. Man aktiviert ("lädt") das Paket mit `library("TurtleGraphics")`.

Bisher haben wir die Befehle einzeln eingegeben. Ein "Programm" ist eine Abfolge von Befehlen. 
- Jetzt schreiben wir uns ein Programm: Es macht ein Quadrat
- Dazu brauchen wir ein neues Fenster, in das wir das Programm eintippen. Im Menü: "New R Script". 
- Der Begriff "Script" ist mehr oder weniger synonym zu "Programm", aber "Skript" impliziert, das es ein einfaches, kurzes Programm ist, dass sich daruf beschränkt, Funktionalität von komplexeren im Hintegrund stehendem Code (zB unser "TurtleGraphics"-Paket) zu nutzen.

Der Code unseres Programm ist wie oben. Nur führen wir jetzt nicht jeden Befehl direkt aus, sondern tippen erst alles ein und führen dann alles zusammen aus.

- Um alle Befehle, also das Skript als Ganzes, auszuführen, drücken wir "Source". 

- Wir können auch einzelne Zeilen einzeln ausführen, wie vorher in der Konsole. Dazu drücken wir "Run". Die Zeile wird in die Konsole kopiert und dann ausgeführt.

- Wir können das Programm nun leicht modifizieren und probieren was sich ändert. Wie, zum Beispiel, wenn wir schräg anfangen? Dazu fügen wir in der Zeile nach `turtle_init()` eine neue Zeile ein: `turtle_left(20)`

- Wir mussten eben bis vier zählen und dieselben Befehle viermal wiederholen. Informatiker wiederholen sich ungern, und ganz besonders möchten sie nie selbst zählen. Dafür hat man ja Computer. Wie bringen wir den Computer dazu, bis 4 zu zählen?

- Wir wollen denselben Block aus (bei uns zwei) Befehlen mehrmals wiederholen. Das nennt man eine Schleife (engl.: loop).

- Wir verwenden dazu die "for"-Konstruktion: `for( i in 1:4 )`. Hier ist `1:5` eine Abkürzung für "die Zahlen von 1 bis 4". Wir wollen also, dass R von 1 bis 4 zählt, und dabei jedesmal die beiden Befehle ausführt. Damit "for" weiß, welche Befehle es wiederholen soll, haben wir sie in geschweiften Klammen zusammen gefasst. Was das "i" macht, kommt später

### Hausaufgabe

1. Installieren Sie R, RStudio und TurtleGraphics auf Ihrem Compter, wie oben erklärt.
2. Versuchen Sie, selbständig ein paar einfache geometrische Formen zu zeichnen, zum Beispiel:
    - ein Quadrat
    - ein schräges Rechteck
    - ein Sechseck
    - ein Pentagramm
    - das "Haus vom Nikolaus"
3. Gelingt es Ihnen, diesen Stern nachzuzeichnen?
![](https://i.imgur.com/5gOEAu5.png)


# 2. Vorlesung (16.11.20)

## Arithmetik

R kann Berechnungen durchführen. 

Beispiele:

- 1+1
- 327 * (15 / 17)
- 2^3

Hier verwenden R Sonderzeichen für mathematische Operatoren (operators):
- Plus (+) und Minus (-) wie üblich.
- zum Multiplizieren: ein Stern (*)
- zum Dividieren: ein Schrägstrich (/, forward slash)
- Ein Caret (oder "Dach", ^) für "hoch" (Potenz)

Ausserdem:
- Es gilt "Punkt vor Strich", und Potenz vor Punkt usw. Es gibt eine ganze Liste, die "operator precedence"
- um Precedence zu ändern, verwendet man Klammern, wie üblich. Aber, anders als in der Schule, nur *runde* Klammern

Es gibt auch Funktionen, zB
- sin, cos, tan für Trigonometrie
- sqrt für "square root" (Quadrat-Wurzel)
- exp für Exponentialfunktion (`exp(x)` bedeutet e^x) und log für (natürlichen) Logarithmus
- log2 und log10 für Logairthmus zur Basis 2 oder 10

Eine Funktion funktioniert wie die Turtle-Befehle: Funktionsname, gefolgt von Funktionsargumenten in Klammern. Neu ist: die Funktion gibt einen Wert zurück (das Ergebnis)

Es gibt auch Vergleichoperatoren:
- Beispiele: `3 > 5` (False), `7+2 == 10` (False), 16/2==8 (True)
- Vergeichsoperatoren: `>`, `<`, `>=`, `<=`, `==` (Wichtig: Gleichheit wird durch `==` bechrieben, nicht `=`!)


Manchmal werden Werte in "scientific notation angegeben", z.B.  3.5e-2 für 3.5 * 10^-2 = 0.035 (Starte mit 3.5, schiebe das Komma um 2 Positionen nach links (-2)).

Wichtig: Im Englischen verwendet man einen Punkt als Dezimaltrenner, nicht ein Komma.


## Variablen 

Eine Variable ist ein Speicherplatz für einen Wert (value) mit einem Namen (name). Variablen weisst man ihren Wert mit dem Zuweisungs-Operator (assignment operator) zu: "<-" (ein Größer-Zeichen, gefolgt von einem Minus), Dann kann man sie verwenden:

```
x <- 7
x
2*x
```

Variablen sind variabel: Man kann ihren Wert ändern:

```
x <- 13
x+1
x <- 19
x-2
```

Variablen-Namen können länger als ein Buchstabe sein. Es empfiehlt sich "deskriptive" Namen zu verwenden.

Variablen können auch das Ergebnis einer Rechnung aufnehmen:

```
x <- 3+7
x+2
```

Der Zuweisungsoperator hat drei Formen, die alle dasselbe bedeuten:

```
x <- 7
7 -> x
x = 7
```

Wichtig: Unterscheide Zuweisung [assignment] (`=`) und Vergleich [comparison] (`==`)

```
x = 3
x == 5
x = 5
x == 5
```

Variablen kann man überall verwenden. Beispiel: ein skalierbares Rechteck

```
length <- 20
width <- length/2

turtle_init()
turtle_forward( width )
turtle_right( 90 )
turtle_forward( length )
turtle_right( 90 )
turtle_forward( width )
turtle_right( 90 )
turtle_forward( length)
```

Wenn wir am Anfang den Wert für `length` ändern, bekommen wir immer ein anderes Rechteck.

Variablen können auch eine Folge von Werten durchlaufen:

```
for( i in 1:10 ) {
   print( i*3 )
}
```

Damit können wir eine Spirale zeichnen:

```
for( i in 1:4 ) {
	turtle_forward( 3*i )
	turtle_right( 90 )
}
```


Variablen können nicht nur Zahlen enthalten:

```
greeting <- "Hello"
greeting
```

## Funktionen

Eben haben wir Code für ein Rechteck gechrieben, das jedes Mal anders aussieht, wenn man die beiden Variablen `width` und `length` ändert, die wir am Anfang definiert hatten.

Das kann man auch professionaller machen:

```
rechteck <- function( length, width ) {
    turtle_init()
    turtle_forward( width )
    turtle_right( 90 )
    turtle_forward( length )
    turtle_right( 90 )
    turtle_forward( width )
    turtle_right( 90 )
    turtle_forward( length )
}
```

Dieser Code definiert eine neue *Funktion*. Die können wir nun genauso aufrufen wie die Funktionen die wir schon kennen (wie zB `turtle_forward`). So können wir nun schreiben:

```
rechteck( 20, 30 )
```

und erhalten ein Rechteck der Länge 20 und Breite 30.

Was hier genau passiert:
Wir rufen die Funktion `rechteck` auf (die wir selbst definiert haben) und übergeben (wie wir es auch bei anderen Funktionen gemacht haben) zwei Funktions-Argumente: 20 und 30. R weist diese den beiden Namen zu, die wir bei der Funktions-Defintion gleich nach `function` angegeben haben. `length` erhält den Wert 20 und `width` den Wert 30. Dann werden die Zeilen im Funktions-Körper (function body) ausgeführt, und aus der Sicht dieser Zeilen existieren zwei Variablen: `length` mit dem Wert 20, und `width` mit dem Wert 30.

Wenn wir die Funktion nochmal mit anderen Argumenten aufrufen, werden die Befehle im Funktionskörper nochmals ausgeführt, aber nun haben `length` und `width` die Werte, die wir dieses mal übergeben haben:

```
rechteck( 40, 10 )
```


## Vektoren

Eine Variable kann auch mehr als nur einen Wert aufnehmen

```
a <- c( 13, 12, 7, 1, 10 )
a
```

Die Funktion "c" (für "concatenate" - "hänge aneinander") baut eine Vektor (vector) zusammen.

Mit Vektoren kann man rechnen:

```
a*2
```

Hier wird nun jeder Wert von a mit 2 multipliziert und wir erhalten den Vektor 26, 24, 14, 2, 20.


## Data frames

Aus mehreren Vektoren kann man sich eine Tabelle (table) bauen. In R nennt man solche Tabellen "data frames":

```
tabelle <- data.frame(
   groesse = c( 160, 187, 192, 175, 179, 171 ),
   gewicht = c( 55, 70, 89, 65, 61 ),
   geschlecht = c( "w", "m", "m", "m", "w", "w" )
)

tabelle
```

Diese Tabelle hat nun drei Spalten (columns) mit Überschriften (column names, oder im R-Jargon: colnames) "groesse", "gewicht" und "geschlecht". Die Tabelle hat 6 Zeilen (rows).


## Plots

Wir können unsere Tabelle jetzt als Streudiagramm ("scatter plot") visualisieren

```
library( ggplot2 )

ggplot( tabelle ) + geom_point( aes( x=groesse, y=gewicht, col=geschlecht ))
```

Wir haben hier das ggplot2-Paket benutzt, dass die ggplot-Funktion zur Verfügung stellt. Der Übergibt man eine Tabelle. In eienr etwas merkwürdigen Syntax fügt man die Details, was genau man will, mit einen "+" hinzu. Wir wollen, dass jede Zeile unserer Tabelle durch einen Punkt dargestellt wird (geom_point), wobei die Tabellen-Spalte "groesse" die x-Koordinate des Punkte angibt, "gewicht" ist die y-Koordinate, und "geschlecht" bestimmt die Farbe (colour).


## Eine größere Tabelle

Hier ist eine Tabelle mit Daten aus der NHANES-Studie des CDC mit Daten von ein paar Tausend zufällig ausgewählten Amerikanern, aus dem Jahr 2019. Wir lesen die Tabelle mit der "read_csv"-Funktion aus dem "readr"-Paket ein. Was "CSV" genau bedeutet, kommt später.

```
library(readr)
read_csv( "tmp/NHANES_J_excerpt.csv" ) -> nhanes
```

Hier können wir wieder einen Plot machen
```
ggplot(nhanes) + geom_point( aes( x=height, y=weight, col=sex ), size=.1 ) 
```

Diesmal haben wir noch `size=.1` angefügt, um die Punkte etwas kleiner zu machen. Da wir hier keinen Spaltennamen verwendet haben, kommt dieses Argument nicht in den `aes`-Block.


## Hausaufgaben

#### Aufgabe 1

Oben haben wir uns eine Funktion definiert, die ein Rechteck zeichnet. Schreiben Sie nun eine Funktion (nennen Sie sie zB `polygon`), die ein gleichseitiges n-Eck zeichnet. Die Funktion soll zwei Argumente nehmen, die Anzehl der Ecken, und die Seitenlänge. Wenn man also dann z.B. `polygon( 3, 20)` schreibt, soll die Schildkröte ein Dreieck zeichnen, dessen Seiten alle die Länge 20 haben, und `polygon( 5, 15 )` erzeugt ein Fünfeck mit Seitenlänge 15.

Tipp: Schauen Sie sich nochmal das Beispiel zu `function` and und das zu `for`. Und überlegen Sie sich (am besten mit Hilfe von ein paar Papier-und-Bleistift-Skizzen): Um welchen Winkel muss die Schildkröte sich bei jeder Ecke eines n-Ecks drehen? Wie berechnet man diesen Winkel, wenn man n weiss?

Tipp 2, Wenn Sie den WInkel nicht finden: Wenn die Schildkröte das ganze Vieleck gemalt hat, sollte sie sich insgesamt um 360 Grad gedreht haben. Damit ist es einfach zu erkennen wie weit sie sich bei jeder der n Ecken drehen muss.

Zusatzaufgabe: Können Sie auch einen Stern mit n Zacken malen?


#### Aufgabe 2

Die Tabelle von der NHANES-Studie, die wir am Schluss verwendet haben, finden Sie hier: https://vorlesungdate-x2v3801.slack.com/files/U01DF9VLKV4/F01EVKDJ54M/nhanes_j_excerpt.csv

1. Lesen Sie die Daten nochmals ein, mit denselben Befehlen wie oben.
2. Erzeugen Sie den Plot "Größe versus Alter" nochmals. Sehen Sie ihn sich genau an. Können Sie sagen, ab welchem Alter wir biologisch er-wachsen sind, also nicht mehr wachsen? Können Sie erkennen, wie viel ein Kind typischerweise wächst zwischen dem 5. und dem 6. Geburtstag. Und wie ist es bei einem Teenager: Wachsen die schneller oder langsamer als kleinere Kinder?
3. Machen Sie noch einen Plot, diesmal Gewicht gegen Größe.


#### Aufgabe 3
Machen Sie die Datei mit der Tabelle mal in einem Texteditor (zB Notepad auf Windows oder TextEdit auf dem Mac). Wieso nennt man dieses Datei-Format wohl "column-separated values" (CSV)? Gelingt es Ihnen, so eine Datei in Excel (oder einem anderen Tabellenkalkualtionsprogramm) einzutippen, als CSV-Datei abszuspeichern und in R zu laden?


#### Aufgabe 4
Nun wissen Sie, wie man Tabellen erzeugt und wie man Scatter-Plots macht. Probieren Sie das an irgendeiner Daten-Tabelle, die Sie im Internet oder sonst wo finden können.