[JS]
[DE]
[USE] plot
[PLUGIN] ml.plugin
[PLUGIN] math.plugin
[PLUGIN] popup.plugin
[PLUGIN] R.plugin
[PLUGIN] file.plugin
[PLUGIN] help.plugin
[PLUGIN] button.plugin
[TITLE] R - Einführung in Datenverarbeitung
[AUTHOR] Stefan Bosse
[VERSION] 11.2023

# Einführung in die Datenverarbeitung mit R (Teil 1)

[FUN]
```js
Plot.create=function (data,options) { drawPlot(0,Plot(data,options)) }
new HelpUI({
  welcome:'Enter search pattern (with optional wildcards *)',
  label:'HelpBot',
  callback:function (text) {
    var result = R.help(text)
    return result?result:'Sorry, found nothing helpful.'
  }
})
```

[TOC]

## Vorwort

Bitte folgenden Code ausführen um notwendige Bibliotheken zu laden. Nicht erforderlich bei nativer R Software.

[R] R Set-up { lines:2; height:5 }
```R
use math,plot
dev.new(width=500)
print("Libraries opened.")
print(R.version)
```

>! Es wird in diesem Kurs der R-Dialekt r+ verwendet. R+ ist eine Reimplementierung von R in JavaScript und läuft direkt in Web Browsern und node webkit Applikationsprogrammen. Es ist keinee Softwareinstallation erforderlich.

- R+ ist nahezu R Syntax mit einigen Ergänzungen die die Programmierung und lesbarkeit von Programmen erleichtern.

- Nicht alle R Packages sind in R+ enthalten, und es kann Abweichungen geben.

- Dennoch lassen sich die meisten öffentlich verfügbaren algorithmischen Lösungen und Hilfestellungen mit R+ umsetzen.

## Literatur

- Lese "Learning R Programming" [Kun Ren,2023](http://edu-9.de/uploads/Lehre/asd3k/tutorials/9781785880629.pdf)

## Variablen und Ausdrücke

Eine Variable ist in *R* eine Referenz auf Werte. Werte können sein:

- Numerische Werte (ganzzahlig, reell) ⇒ `numeric`
- Logische Werte (Boolean) ⇒ `logical`
- Textzeichenketten ⇒ `character`
- Vektoren (Arrays, Matrizen)
- Listen ⇒ `list`
- Funktionen! ⇒ `function`

Variablen kann ein neuer Wert (also eine Referenz) zugewiesen werden mit den `<-` und `=` Operationen. Der Pfeiloperator kann bevorzugt verwendet werden, der Unterschied zwischen beiden ist marginal, wobei `=` noch für benannte Funktionsparameter verwendet wird. Ausdrücke können beliebibig komplex sein, teils aus Operanden mit unterschiedlichen Datentypen bestehen. Es kann aber auch zu typsisierten Fehlermeldungen kommen. So können in R Zeichenketten nicht mittels `+` verknüpft werden (es ist die Funktion `paste` zu verwenden).

[R] Variablen und Ausdrücke { lines:10; height:5 }
```R
x<-1
y=2
z<-(x-y)/2
print(z)
```

>! Variablenamen können aus den Zeichen `a`-`z`, `A`-`Z`, den Zahlen `0`-`9` (außer an erster Stelle) und einem Punkt `.` bestehn.

- Die Punktschreibweise von Variablename kann für eine semantische Gruppierung genutzt werden, z.B. *data*, *data.train*, *data.test*, *data.analysis* usw.

[TODO]
Zerlege folgenden komplexen Ausdruck in eine Sequenz von einfachen (max. eine Operation) unter Zuhilfename von weiteren Variablen.

[R] Zerlegung eines kompelxen Ausdrucks { lines:10; height:5 }
```R
a<-1 b<-2 c<-3
z<-(a+b+c)/(a-b-c)*a*b*c
print(z)
```

### Kontext und Workspace

Alle Variablen werden in einem globalen Arbeitsbereich (Kontext) angelegt, der bereits vordefinierte Werte enthält. Innerhalb von Funktionen existiert ein lokaler Kontext und Arbeitsbereicj, und Variablenzuweisungen finden in diesem statt. Funkctionsparameter sind immer lokal.

[R] Unterschiedliche Sichtbarkeit von Variablen { lines:10; height:5 }
```R
x = 1234
function foo(x) {
 x2 = x*2
 x=x2+1
 x2
}
x2 = foo(x)
print(paste(x,x2))
```

[QUESTION]
Welche Sichtbarkeit haben die beiden Variablen *x* und *x2* in der Funktion *foo*?

[INPUT]

## Zeichenketten

Konstante Zeichenketten werden mit der `"ABC"`Syntax eingeführt. Zeichenketten können mit der `paste` Funktion zusammengefhrt werden (jeweils mit Trennzeichen):

Folgende Basisoperationen existieren:

- `abbreviate` liefert eine Abkürzung einer Zeichenkette
- `chartr(old,new,x)` ersetzt einen oder mehrere Zeichen in einer Zeichenkette (Ergebnis wird in einer Liste zurückgegeben)
- `strsplit(x,split)` zerlegt eine Zeichenkette in eine Liste von Tokens
- `substr(x,start,stop)` liefert eine Teilzeichenkette beginnend bei *start* und bis *stop* (Zeichenposition)
- `tolower` wandelt alle Zeichen auf Kleinschreibung um
- `toupper` wandelt alle Zeichen auf Großschreibung um

>! Funktionen erwarten Argumente in der Reihenfolge der Parameterdefinition, z.B. *foo*(*a*,*b*,*c*) erwartet als erstes Argument *a*, dann *b*, d.h., *foo*(1,2,3). Alternativ können die Argumente auch den Parameternamen zugewiesen werden, wo die Reihenfolge dann keine Rolle mehr spielt, also z.B. *foo*(*c*=3,*a*=1,*b*=2)

[R] Zeichenketten { lines:10; height:10 }
```R
s1<-"Hello"
s2<-"World"
s3<-paste(s1,s2)
print(paste(s3,z))
print(tolower(paste(s1,s2)))
print(abbreviate(paste(s1,s2,z)))
print(strsplit(s3," "))
```

[TODO]
Zerlege die Zeichenkette "A-1 B-2 C-1" in 1. Token die durch ein Leerzeichen getrennt sind, und dann 2. diese Token zerlegen mittels des Bindestrichs. **Hinweis: Die Stringoperationnen können auch auf Listen angewendet werden!**

[R] Zerlegung einer Zeichenkette { lines:10; height:5 }
```R
s<-"A-1 B-2 C-1"
# 1. Trennung durch Leerzeichen
# 2. Trennung durch Bindestrich
```

## Listen

Listen sind geordnete Werte die entweder über einen numerischen Index oder über einen Elementnamen referenziert werden können. Listen werden mit der `list` Funktion erzeugt. Ein numerischer Selektor wird durch den `[i]` Operator eingeleitet.

>! Achtung: Liefert hier wieder eine Liste mit einem Element! Will man das Listenelement direkt lesen verwendet man den ``[[i]]` Operator!

Benannte Listenelemente könne bei der Erzeugung mittels `name=val` erstellt werden, oder später durch die `names` Funktion. Listen könen mehrsortig sein (d..h., Elemente von verschiedenen Datentyp). Neue Elemnte können an einer bestimmten Position mittels ``append` hinzugefügt werden.

[R] Listen { lines:10; height:15 }
```R
# Numerisch indizierte Listenelemente
sl<-list("Hello","World")
print(sl[1])
print(paste(sl[1],sl[2]))
print(paste(sl[[1]],sl[[2]]))
# Benannte Listenelemente
sl<-list(x=1,y=2,z=3)
print(sl)
print(sl[1])
print(sl[[1]])
print(sl[["x"]])
print(sl$x+sl$y-sl$z)
# Veränderung von Listen
sl$x<-10
sl[1:2]<-0
print(sl)
sl<-append(sl,123)
print(sl)
```

>! In R+ gibt es die Kurzschreibweise `{a=1,b=2,..}` für `list(a=1,b)2,..)`! Es können auch numerisch indizierte Listen mittels der Syntax `{1,2,3,..}` (oder mit *list*) erzeugt werden. Hier ist nur eine numerische Referernzierung der Element möglich, also z.B. `v[1]`.

[TODO]
Zerlege die Zeichenkette "A-1 B-2 C-1" in Tokens durch Leerzeichen getrennt, verändere die Reihenfolge der Listenelement deart dass C B A als Reihenfolge entsteht, und füge die Listenelement wieder zu einer Textzeichenkette zusammen.

[R] Zerlegung einer Zeichenkette { lines:10; height:5 }
```R
s<-"A-1 B-2 C-1"
# 1. Trennung durch Leerzeichen => A B C
# 2. Umsortieren mit Hilfsvariable => C B A
# 2. Zusammenfügung zu einer neuen Liste
```

## Vektoren

Vektoren sind ähnlich Listen. Vektoren bieten anders als Listen die Möglichkeit Werte in kompakten (linearen) Arrays zu speichern. Daher kann ein bestimmter Datentype (*mode*) angegeben werden. Ein von einer Argumetenliste initialisierter Vektor wird mit `c`, ein konstant initialisierter mit `vector` erzeugt. Vektoren sind immer eindimensional. Mehrdimensionale "Vektoren" sind Arrays und Matrizen (zweidimensional), Teilbereiche eines Vektors können durch den Bracketoperator ausgewählt werden.

Folgende Vektorfunktionen sind wichtig:
- Aggregatoperationen wie `min`, `max`, `range`, `mean`, `sum`
- Arithmetische, relationale, und logische Operatione (elementweise)
- Statistische Analyse mit `fivenum`; liefert {min, quantile1, median, mean, qunatile3, max} bei numerischen Vektoren
- Statistische Analyse mit `table` bei kategorischen Vektoren

[R] Datenvektoren { lines:10; height:15 }
```R
primes<-c(1,3,5,7,11,13,17)
data <- vector(mode="int8",100)
# Wert hinzufügen
primes<-c(primes,23)
print(primes)
# Werte verändern (was passiert?)
data[1:5]<-1:5
# Formatierte Ausgabe eines Vektors
print(data)
# Numerische Analyse
print(fivenum(primes))
```

>@ In R+ gibt es die Kurzschreibweise `[v1,v2,..]` für `c(v1,v2,..)` um initialisierte vektoren zu erzeugen!

>! In R+ werden Matrizen spaltenweise organisiert (in R zeilenweise), d.h., eine Initialisierung mit einem Vektor `[1,2,3,4]` und zwei Spalten führt zu den Werten 1 und 2 in der ersten Zeile!

[TODO]
Analysiere die folgenden Vektoren klassengerecht, notiere die Ergebnisse. Was bedeuten die statistischen Werte? Führe eine Recherche durch.

[R] Statistische Analyse von Vektoren { lines:10; height:5 }
```R
vn <- [100,5,99,-4,100,110,55]
vs <- ["a","b","a","c","a","b","b"]
# Analysen
```
[INPUT]

## Matrizen

Eine Matrix (ähnlich einem Datenrahmen, folgendes gilt i.A. auch für Datenrahmen) ist eine zweidimensionale Tabelle und wird mit der `matrix(init,nrow,ncol)` Funktion erzeugt. Der Datentyp muss skalar bzw. atomar sein (`numeric`, `logical`, `character').

Folgende Matrixfunktionen sind wichtig:

- `col(m)` liefert eine Matrix von *m* mit Spaltenindexwerten
- `diag(m)` liefert die Diagonalelemente einer Matrix
- `dim(m)` liefert die Dimensionen einer Matrix
- `row(m)` liefert eine Matrix von *m* mit Zeilenindexwerten
- `nrow`, `ncol`, `colnames` um einzelne Informationen über die Matrix zu erhalten
- Aggregatoperationen wie `min`, `max`, `minMax`, `range`, `mean`, `sum` und `fivenum` (Vorsicht beu fivenum: Median und Quantile Berechnung kann sehr rechenintensitiv sein)
- Arithmetische, relationale, und logische Operatione (elementweise), und Skalarprodukt `%*%`

[R] Matrixerzeugung und Operationen { lines:10; height:10 }
```R
data1<-matrix(0,nrow=5,ncol=3)
print(data1)
data2<-matrix(1:9,nrow=3,ncol=3)
print(data2)
data2.diag <- diag(data2)
data2.diagalt <- data2[col(data1)==row(data1)]
```

>! In R+ gibt es die Kurzschreibweise `[|v11,v12,..,c1n;c21,c22,..|]`  anstelle für `matrix(c(v11,...),...)` um initialisierte Matrizen zu erzeugen!

[QUESTION]
Was ist der Unterschied bei der Initialisierung von *data1* und *data2*? Was passiert wenn anstelle `1:15` der Bereichsvektor `1:3` verwendet wird?

[INPUT]

Relationale Ausdrück angewendet auf Matrizen (oder natürlich auch Vektoren) liefern eine Boolesche Matrix oder einen Vektor (entweder mit Booleschen Werten FALSE oder TRUE, oder numerisch mit 0 und 1 Werten gefüllt)!

Will man die Positionen (row,col) haben kann man die `which` Funktion verwenden, die entweder den linearen Index (spaltenorientiert) oder mit der `arr.ind=TRUE` Option auch als Matrix liefert.

[R] Relationale Operationen auf Matrizen { lines:10; height:10 }
```R
data3<-matrix(runif(9),nrow=3,ncol=3)
print(data3)
print(data3 > 0.5)
print(data3[data3 > 0.5])
print(which(data3 > 0.5,arr.ind=TRUE))
data3[data3<0.5]=0
print(data3)
```

[QUESTION]
Wenn ein Bild durch eine Matrix repärsentiert wird, wie kann eine Binärisierung des Bildes erreicht werden? Wählen sie im folgenden Beispiel den Schwellwert mit *t*=0.5. Alle Matrixelemente mit *x* < *t* sollen zu Null, und alle mit *x* ≥ *t* zu 1 werden.

```R
data3<-matrix(runif(9),nrow=3,ncol=3)
# data3.bin[]=....
print(data3.bin)
```

## Indizierung von Aggregationen

- Ein Vektor- oder Listenelement kann durch den Bracketoperator `v[i]` sowohl lesend als auch schreibend ausgewählt werden.
- Bei Listen muss der Doppelbracketoperator `l[[i]]` verwendet werden um an das Listenelement zu gelangen
- Benannte Vektor- und Listenelements können auch über ihren Elementname mit `v$x` refernziert werden
- Bereiche (Bereichsselektierung) kann durch den `[a:b]` Operator mit *index*={a,a+1,..,b} ausgewählt werden
- Mehrdimensionale Aggregationen wie Arrays, Matrizen, und Datenrahmen (dataframe) können durch `[row,col,..]` referenziert werden
- Bei mehrdimensionalen Aggregationen kann ein Leerfeld in der Kommaliste den ganzen Bereich dieser Dimension festlegen, siehe folgendes Beispiel.

[R]  Elementauswahl von Matrizen { lines:10; height:10 }
```R
data<-matrix(1:15,nrow=5,ncol=3)
data.first <- data[1,1]
data.col1 <- data[,1]
data.row1 <- data[1,]
data.train <- data[1:2,]
data.test <- data[3:5,]
print(data.row1)
print(data.test)
```

## Arithmetik

Arithemtische (`+`, `-`, `*`, `/`, `%`, `%%`), relationale  (`<`, `>`, `>=`, `<=`, `==`, `!=`) und logische (`&`, `|`) Operationen können auf einer Vielzahl von Datentypen inklusive Aggregationen wie Listen und Vektoren direkt angewendet werden. Bei Listen und Vektoren werden diese Operationen elementweise angewendet und erzeugen einen neuen Vektor.

[R] Arithmetik auf Datenvektoren { lines:10; height:10 }
```R
primes<-[1,3,5,7,11,13,17]
primes<-primes + 1
print(primes)
primes.short <- primes[1:3]
primes.large <- primes[primes>5]
print(primes.short)
print(primes.large)
```

[TODO]
Zerlege und analysiere den `primes[primes>5]` Ausdruck. Was liefert `primes>5` und wie funktioniert die Reduktion (Filterung) des Vektors? Erstelle einen Teilvektor aus *primes* der nur Werte < 5 und Werte > 10 enthält.

[INPUT]

[R] Bereichsselektion eines Datenvektors { lines:10; height:10 }
```R
primes<-[1,3,5,7,11,13,17,23,29]
# primes.selected <-  
```

## Schleifen und Bedingte Anweisungen

R bietet Schleifen für die wiederholte Ausführung von Anweisungen und bedingte Anweisungen (if-else). Schleifen sind Iteratoren über Bereiche, Vektoren, oder Listen, und für wiederholte arithmetische Berechnungen hilfreich.

[R] Schleifen und bedingte Anweisungen { lines:10; height:10 }
```R
x = 0
for (i in 1:10) {
 x = x + i
 if (x> 10) x=x/2
 else x=x+1
}
print(x)
```

[TODO]
Berechne die Summe eines Vektors

[R]
```R
x = [1,2,3,4]
sum = 0
for (i in x) {
  # TODO
}
print(sum)
```

## Datentabellen (Data Frames)

Eine Datentabelle besteht auf Spalten und Zeilen. Eine Zeile kann man als Liste auffassen, i.A. mit benannten Spaltennamen (oder numerisch indiziert). Die Zeilen können auch mit Namen versehen sein, i.A. werden Zeilen aber numerisch indiziert (erste Zeile nesitzt den Index 1).

- Datentabellen werden in R als *data.frame* mit der Funktion `data.frame()` erzeugt.

- Es gibt auch Funktionen, wie z.B. das Lesen und Parsen einer CSV Datei, die Daten in Form eines *data.frame* objects erzeugen.

- Häufig werden Datentabelle aus Spaltenvektoren oder Spaltenlisten erzeugt.

[R] Erzeugung von Datentabellen (data.frame) { lines:10; height:10 }
```R
df <- data.frame(
  x = [1,2,3,4,5,6,7,8],
  y = [0,1,0,1,1,1,1,0]
)
print(df)
```

Es gibt eine Vielzahl von Operationen und Funktionen die man auf Datentabellen anwenden kann:

- `nrow`, `ncol`, `colnames` und `rownames`  liefern Informationen über die Tabelle;

- `colSums` und `rowSums` liefern numerische Aggregate der Zeilen und Spalten

- Die Selektion einer Zeile mittels `df[row,]` liefert eine Liste

- Der Selektor `df[row,]` kann auch auf der linken Seite einer Zuweisung verwendet werden um eine bestehende Zeile zu ändern oder eine Zeile hinzuzufügren

- Spalten können anhand der Spaltennamen ausgewählt werden (lesend und verändernd) via `df$col` oder `df['colname']`, ebenso können neue Spalten hinzugefügt werden

[TODO]
Erzeuge eine Datentabelle mit den Spalten `x,sin,cos,tan` für die Werte *x* im bereich 0 bis 6 in den Abständen 0.5. Die Spalten `sin,cos,tan` sollen mit den mathematischen Funktionen programmatisch berechnet werden.

[R]
```R
x <- [0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6]
# df ...
print(df)
```

# Analyse eines Beispieldatensatzes

## Daten

[DATA] dataIRIS:data/iris.json

[FUN]
```js
console.log(dataIRIS)
R.addValue('data.iris',{
  type : 'data.frame',
  nrow : dataIRIS.length,
  ncol : 5,
  colnames : Object.keys(dataIRIS[0]),
  value : dataIRIS.map((row) => (Object.keys(dataIRIS[0]).map((k) => row[k])))
})
console.log('R init done.')
```

- Botanischer Standarddatensatz "iris"
- Numerische Eingabevariablen (***X***)
- Kategorische Ausgabevariable (*Y*)

Der Datensatz ist bereits im Notebook enthalten und wird als Datenrahmen (data.frame) `data.iris` zur Verfügung gestellt!

[R] Arithmetik auf Datenvektoren { lines:10; height:10 }
```R
print(colnames(data.iris))
print(paste(nrow(data.iris),ncol(data.iris)))
```
## Zerlgeung der Tabelle

[R] Zerlegung in Spalten { lines:10; height:10 }
```R
x1 <- data.iris[,1]
x2 <- data.iris[,2]
x3 <- data.iris[,3]
x4 <- data.iris[,4]
y  <- data.iris[,5]
print(summary(x1))
```

Die Zielvariable *y* liegt als kategorische Variable vor. Eine Kodierung in eine numerische kann wie folgt mit der *factor* Funktion durchgeführt werden:

[R] Kodierung { lines:10; height:10 }
```R
y.factor <- factor(y)
y.levels <- levels(y.factor)
y.code <- as.numeric(y.factor)
print(y.code)
```

[QUESTION]
Was enthält `y.code`? Was bewirkt `factor` (verwende print) und was enthält `y.levels`?

[INPUT]

## Analysefunktionen

Die universellste Analysefunktion ist `summary`, gefolgt von `fivenum` für numerische und `table` für kategorische Variablen.

[TODO]
Analysiere den Datensatz mit 1. `summary`, 2. Einzelne Spalten mit `fivenum` und `table`. Welche Eigenschaften haben die einzelnen Variablen (Attribute)?

>! R summary liefert bei kategorischen Variablen keine Verteilungsanalyse. Mit dem Argument `extended=TRUE` kann diese hier aktivuiert werden.

[R] Arithmetik auf Datenvektoren { lines:10; height:10 }
```R
# Analyse von data.iris
# summary(..,extended=TRUE)
# fivenum
# ...
```

[INPUT]

## Grafische Analyse

Die `plot(x,y)` Funktion ist universell und kann verschiedene Datenformate darstellen. Am häuigsten wird man sie für Punkt- und Linienverläufe verwenden. Die Breite (oder Höhe) des Plotfensters kann mit `dev.new(width=300)` gesetzt werden.

[R] Beispiele für die Plot Funktion { lines:10; height:10 }
```R
x<-sapply((1:100),function (x) { sin(x/10) })
plot(x)
plot(x,x*x)
```

[TODO]
Benutzte die `plot(x,y)` Funktion um Zusammenhänge zwischen den einzlenen Variablen *x*~1~ bis *x*~4~ und mit der Zielvariablen *y.code* herzustellen. Findet man Strukturen, können schon geeignete Kandidaten für die Klassifikation gefunden werden?

[R] Grafische Analyse von Attributen { lines:10; height:10 }
```R
# plot(x1,x2) usw.
```

[INPUT]

## X-Y Partitionierung

Grafisch konnten bereits Eingabevariablen mit der (nuemrisch kodierten) Ausgabevariable in einen Zusammenhang gesetzt werden. Analytisch kann man neben dem Informationsgewinn eine einfache Partitionierung der numerischen Eingabevariablen nach der Zielvariable vornehmen. Das ist im nächsten Beispiel gezeigt.

[R] Partitionierung der x-Werte nach (kategorischen) y-Werten { lines:10; height:10 }
```R
# Create x ~ y partitions for each attribute
x1.partitions <- list(A=x1[y==y.levels[1]],
                      B=x1[y==y.levels[2]],
                      C=x1[y==y.levels[3]])
x2.partitions <- list(A=x2[y==y.levels[1]],
                      B=x2[y==y.levels[2]],
                      C=x2[y==y.levels[3]])
x3.partitions <- list(A=x3[y==y.levels[1]],
                      B=x3[y==y.levels[2]],
                      C=x3[y==y.levels[3]])
x4.partitions <- list(A=x4[y==y.levels[1]],
                      B=x4[y==y.levels[2]],
                      C=x4[y==y.levels[3]])
```

[TODO]
Analysiere die Partitionen. Lassen sich geeignete Teilungspunkte für wenigstens einer Zweiklassenseparation mit einer der Attribute erreichen?

[R] Analyse der Partitionen { lines:10; height:10 }
```R
print(list(var="x1",
           A=range(x1.partitions$A),
           B=range(x1.partitions$B),
           C=range(x1.partitions$C)))
# x2 x3 x4
```

[INPUT]

---

[BUTTON] Hilfe { action:post; label:Absenden; style:"color:red" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Frage'],
  email:{from:'$Email', to:'sbosse@uni-bremen.de', name:'$Name'},
  subject:'Hilfe Kurs ML $TITLE',
  message:'$Name: $Frage',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Einreichung (Assignment #01-46158 ) { action:post; label:Absenden; style:"color:green" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['Name','Email','Pin','Kommentar'],
  submit: { from:'$Email', to:'sbosse@uni-bremen.de' },
  assignment:'01-46158',
  name : '$Name',
  comment : '$Kommentar',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:1827,
}
```

[BUTTON] Prüfen { action:post; label:Laden; style:"color:browm" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Pin'],
  load: { id:'$ID' },
  pin:[1827,9223],
}
```

[BUTTON] Bewerten (Lehrer) { action:post; label:Absenden; style:"color:blue" }
```
{
  url:'edu-9.de:28888',
  // url:'localhost:28888',
  form:['ID','Marking','Pin','Remarks'],
  submit: { id:'$ID', from:'sbosse@uni-bremen.de', name:'$Name' },
  marks : '$Marking',
  remarks : '$Remarks',
  attachments:[{filename:'$FILE.json',content:'$CODE'}],
  pin:9223,
}
```

---

Einführung in die Datenverarbeitung mit R (Teil 1)

Inhalt.

Einführung in die Datenverarbeitung mit R (Teil 1)

Vorwort

Literatur

Variablen und Ausdrücke

Kontext und Workspace

Zeichenketten

Listen

Vektoren

Matrizen

Indizierung von Aggregationen

Arithmetik

Schleifen und Bedingte Anweisungen

Datentabellen (Data Frames)

Analyse eines Beispieldatensatzes

Daten

Zerlgeung der Tabelle

Analysefunktionen

Grafische Analyse

X-Y Partitionierung

Vorwort

Bitte folgenden Code ausführen um notwendige Bibliotheken zu laden. Nicht erforderlich bei nativer R Software.

R Set-up

use math,plot
dev.new(width=500)
print("Libraries opened.")
print(R.version)

▸

[]

✗

≡

Es wird in diesem Kurs der R-Dialekt r+ verwendet. R+ ist eine Reimplementierung von R in JavaScript und läuft direkt in Web Browsern und node webkit Applikationsprogrammen. Es ist keinee Softwareinstallation erforderlich.

R+ ist nahezu R Syntax mit einigen Ergänzungen die die Programmierung und lesbarkeit von Programmen erleichtern.
Nicht alle R Packages sind in R+ enthalten, und es kann Abweichungen geben.
Dennoch lassen sich die meisten öffentlich verfügbaren algorithmischen Lösungen und Hilfestellungen mit R+ umsetzen.

Literatur

Lese "Learning R Programming" Kun Ren,2023

Variablen und Ausdrücke

Eine Variable ist in R eine Referenz auf Werte. Werte können sein:

Numerische Werte (ganzzahlig, reell) ⇒ numeric
Logische Werte (Boolean) ⇒ logical
Textzeichenketten ⇒ character
Vektoren (Arrays, Matrizen)
Listen ⇒ list
Funktionen! ⇒ function

Variablen kann ein neuer Wert (also eine Referenz) zugewiesen werden mit den <- und = Operationen. Der Pfeiloperator kann bevorzugt verwendet werden, der Unterschied zwischen beiden ist marginal, wobei = noch für benannte Funktionsparameter verwendet wird. Ausdrücke können beliebibig komplex sein, teils aus Operanden mit unterschiedlichen Datentypen bestehen. Es kann aber auch zu typsisierten Fehlermeldungen kommen. So können in R Zeichenketten nicht mittels + verknüpft werden (es ist die Funktion paste zu verwenden).

Variablen und Ausdrücke

x<-1
y=2
z<-(x-y)/2
print(z)

▸

[]

✗

≡

Variablenamen können aus den Zeichen a-z, A-Z, den Zahlen 0-9 (außer an erster Stelle) und einem Punkt . bestehn.

Die Punktschreibweise von Variablename kann für eine semantische Gruppierung genutzt werden, z.B. data, data.train, data.test, data.analysis usw.

Aufgabe. Zerlege folgenden komplexen Ausdruck in eine Sequenz von einfachen (max. eine Operation) unter Zuhilfename von weiteren Variablen.

Zerlegung eines kompelxen Ausdrucks

a<-1 b<-2 c<-3
z<-(a+b+c)/(a-b-c)*a*b*c
print(z)

▸

[]

✗

≡

Kontext und Workspace

Unterschiedliche Sichtbarkeit von Variablen

x = 1234
function foo(x) {
 x2 = x*2
 x=x2+1
 x2
}
x2 = foo(x)
print(paste(x,x2))

▸

[]

✗

≡

Frage. Welche Sichtbarkeit haben die beiden Variablen x und x2 in der Funktion foo?

Zeichenketten

Konstante Zeichenketten werden mit der "ABC"Syntax eingeführt. Zeichenketten können mit der paste Funktion zusammengefhrt werden (jeweils mit Trennzeichen):

Folgende Basisoperationen existieren:

abbreviate liefert eine Abkürzung einer Zeichenkette
chartr(old,new,x) ersetzt einen oder mehrere Zeichen in einer Zeichenkette (Ergebnis wird in einer Liste zurückgegeben)
strsplit(x,split) zerlegt eine Zeichenkette in eine Liste von Tokens
substr(x,start,stop) liefert eine Teilzeichenkette beginnend bei start und bis stop (Zeichenposition)
tolower wandelt alle Zeichen auf Kleinschreibung um
toupper wandelt alle Zeichen auf Großschreibung um

Funktionen erwarten Argumente in der Reihenfolge der Parameterdefinition, z.B. foo(a,b,c) erwartet als erstes Argument a, dann b, d.h., foo(1,2,3). Alternativ können die Argumente auch den Parameternamen zugewiesen werden, wo die Reihenfolge dann keine Rolle mehr spielt, also z.B. foo(c=3,a=1,b=2)

Zeichenketten

s1<-"Hello"
s2<-"World"
s3<-paste(s1,s2)
print(paste(s3,z))
print(tolower(paste(s1,s2)))
print(abbreviate(paste(s1,s2,z)))
print(strsplit(s3," "))

▸

[]

✗

≡

Aufgabe. Zerlege die Zeichenkette "A-1 B-2 C-1" in 1. Token die durch ein Leerzeichen getrennt sind, und dann 2. diese Token zerlegen mittels des Bindestrichs. Hinweis: Die Stringoperationnen können auch auf Listen angewendet werden!

Zerlegung einer Zeichenkette

s<-"A-1 B-2 C-1"
# 1. Trennung durch Leerzeichen
# 2. Trennung durch Bindestrich

▸

[]

✗

≡

Listen

Listen sind geordnete Werte die entweder über einen numerischen Index oder über einen Elementnamen referenziert werden können. Listen werden mit der list Funktion erzeugt. Ein numerischer Selektor wird durch den [i] Operator eingeleitet.

Achtung: Liefert hier wieder eine Liste mit einem Element! Will man das Listenelement direkt lesen verwendet man den [[i]]` Operator!

Benannte Listenelemente könne bei der Erzeugung mittels name=val erstellt werden, oder später durch die names Funktion. Listen könen mehrsortig sein (d..h., Elemente von verschiedenen Datentyp). Neue Elemnte können an einer bestimmten Position mittels append` hinzugefügt werden.

Listen

# Numerisch indizierte Listenelemente
sl<-list("Hello","World")
print(sl[1])
print(paste(sl[1],sl[2]))
print(paste(sl[[1]],sl[[2]]))
# Benannte Listenelemente
sl<-list(x=1,y=2,z=3)
print(sl)
print(sl[1])
print(sl[[1]])
print(sl[["x"]])
print(sl$x+sl$y-sl$z)
# Veränderung von Listen
sl$x<-10
sl[1:2]<-0
print(sl)
sl<-append(sl,123)
print(sl)

▸

[]

✗

≡

In R+ gibt es die Kurzschreibweise {a=1,b=2,..} für list(a=1,b)2,..)! Es können auch numerisch indizierte Listen mittels der Syntax {1,2,3,..} (oder mit list) erzeugt werden. Hier ist nur eine numerische Referernzierung der Element möglich, also z.B. v[1].

Aufgabe. Zerlege die Zeichenkette "A-1 B-2 C-1" in Tokens durch Leerzeichen getrennt, verändere die Reihenfolge der Listenelement deart dass C B A als Reihenfolge entsteht, und füge die Listenelement wieder zu einer Textzeichenkette zusammen.

Zerlegung einer Zeichenkette

s<-"A-1 B-2 C-1"
# 1. Trennung durch Leerzeichen => A B C
# 2. Umsortieren mit Hilfsvariable => C B A
# 2. Zusammenfügung zu einer neuen Liste

▸

[]

✗

≡

Vektoren

Vektoren sind ähnlich Listen. Vektoren bieten anders als Listen die Möglichkeit Werte in kompakten (linearen) Arrays zu speichern. Daher kann ein bestimmter Datentype (mode) angegeben werden. Ein von einer Argumetenliste initialisierter Vektor wird mit c, ein konstant initialisierter mit vector erzeugt. Vektoren sind immer eindimensional. Mehrdimensionale "Vektoren" sind Arrays und Matrizen (zweidimensional), Teilbereiche eines Vektors können durch den Bracketoperator ausgewählt werden.

Folgende Vektorfunktionen sind wichtig:

Aggregatoperationen wie min, max, range, mean, sum
Arithmetische, relationale, und logische Operatione (elementweise)
Statistische Analyse mit fivenum; liefert {min, quantile1, median, mean, qunatile3, max} bei numerischen Vektoren
Statistische Analyse mit table bei kategorischen Vektoren

Datenvektoren

primes<-c(1,3,5,7,11,13,17)
data <- vector(mode="int8",100)
# Wert hinzufügen
primes<-c(primes,23)
print(primes)
# Werte verändern (was passiert?)
data[1:5]<-1:5
# Formatierte Ausgabe eines Vektors
print(data)
# Numerische Analyse
print(fivenum(primes))

▸

[]

✗

≡

In R+ gibt es die Kurzschreibweise [v1,v2,..] für c(v1,v2,..) um initialisierte vektoren zu erzeugen!

In R+ werden Matrizen spaltenweise organisiert (in R zeilenweise), d.h., eine Initialisierung mit einem Vektor [1,2,3,4] und zwei Spalten führt zu den Werten 1 und 2 in der ersten Zeile!

Aufgabe. Analysiere die folgenden Vektoren klassengerecht, notiere die Ergebnisse. Was bedeuten die statistischen Werte? Führe eine Recherche durch.

Statistische Analyse von Vektoren

vn <- [100,5,99,-4,100,110,55]
vs <- ["a","b","a","c","a","b","b"]
# Analysen

▸

[]

✗

≡

Matrizen

Eine Matrix (ähnlich einem Datenrahmen, folgendes gilt i.A. auch für Datenrahmen) ist eine zweidimensionale Tabelle und wird mit der matrix(init,nrow,ncol) Funktion erzeugt. Der Datentyp muss skalar bzw. atomar sein (numeric, logical, `character').

Folgende Matrixfunktionen sind wichtig:

col(m) liefert eine Matrix von m mit Spaltenindexwerten
diag(m) liefert die Diagonalelemente einer Matrix
dim(m) liefert die Dimensionen einer Matrix
row(m) liefert eine Matrix von m mit Zeilenindexwerten
nrow, ncol, colnames um einzelne Informationen über die Matrix zu erhalten
Aggregatoperationen wie min, max, minMax, range, mean, sum und fivenum (Vorsicht beu fivenum: Median und Quantile Berechnung kann sehr rechenintensitiv sein)
Arithmetische, relationale, und logische Operatione (elementweise), und Skalarprodukt %*%

Matrixerzeugung und Operationen

data1<-matrix(0,nrow=5,ncol=3)
print(data1)
data2<-matrix(1:9,nrow=3,ncol=3)
print(data2)
data2.diag <- diag(data2)
data2.diagalt <- data2[col(data1)==row(data1)]

▸

[]

✗

≡

In R+ gibt es die Kurzschreibweise [|v11,v12,..,c1n;c21,c22,..|] anstelle für matrix(c(v11,...),...) um initialisierte Matrizen zu erzeugen!

Frage. Was ist der Unterschied bei der Initialisierung von data1 und data2? Was passiert wenn anstelle 1:15 der Bereichsvektor 1:3 verwendet wird?

Will man die Positionen (row,col) haben kann man die which Funktion verwenden, die entweder den linearen Index (spaltenorientiert) oder mit der arr.ind=TRUE Option auch als Matrix liefert.

Relationale Operationen auf Matrizen

data3<-matrix(runif(9),nrow=3,ncol=3)
print(data3)
print(data3 > 0.5)
print(data3[data3 > 0.5])
print(which(data3 > 0.5,arr.ind=TRUE))
data3[data3<0.5]=0
print(data3)

▸

[]

✗

≡

Frage. Wenn ein Bild durch eine Matrix repärsentiert wird, wie kann eine Binärisierung des Bildes erreicht werden? Wählen sie im folgenden Beispiel den Schwellwert mit t=0.5. Alle Matrixelemente mit x < t sollen zu Null, und alle mit x ≥ t zu 1 werden.

data3<-matrix(runif(9),nrow=3,ncol=3)
# data3.bin[]=....
print(data3.bin)

Indizierung von Aggregationen

Ein Vektor- oder Listenelement kann durch den Bracketoperator v[i] sowohl lesend als auch schreibend ausgewählt werden.
Bei Listen muss der Doppelbracketoperator l[[i]] verwendet werden um an das Listenelement zu gelangen
Benannte Vektor- und Listenelements können auch über ihren Elementname mit v$x refernziert werden
Bereiche (Bereichsselektierung) kann durch den [a:b] Operator mit index={a,a+1,..,b} ausgewählt werden
Mehrdimensionale Aggregationen wie Arrays, Matrizen, und Datenrahmen (dataframe) können durch [row,col,..] referenziert werden
Bei mehrdimensionalen Aggregationen kann ein Leerfeld in der Kommaliste den ganzen Bereich dieser Dimension festlegen, siehe folgendes Beispiel.

Elementauswahl von Matrizen

data<-matrix(1:15,nrow=5,ncol=3)
data.first <- data[1,1]
data.col1 <- data[,1]
data.row1 <- data[1,]
data.train <- data[1:2,]
data.test <- data[3:5,]
print(data.row1)
print(data.test)

▸

[]

✗

≡

Arithmetik

Arithemtische (+, -, *, /, %, %%), relationale (<, >, >=, <=, ==, !=) und logische (&, |) Operationen können auf einer Vielzahl von Datentypen inklusive Aggregationen wie Listen und Vektoren direkt angewendet werden. Bei Listen und Vektoren werden diese Operationen elementweise angewendet und erzeugen einen neuen Vektor.

Arithmetik auf Datenvektoren

primes<-[1,3,5,7,11,13,17]
primes<-primes + 1
print(primes)
primes.short <- primes[1:3]
primes.large <- primes[primes>5]
print(primes.short)
print(primes.large)

▸

[]

✗

≡

Aufgabe. Zerlege und analysiere den primes[primes>5] Ausdruck. Was liefert primes>5 und wie funktioniert die Reduktion (Filterung) des Vektors? Erstelle einen Teilvektor aus primes der nur Werte < 5 und Werte > 10 enthält.

Bereichsselektion eines Datenvektors

primes<-[1,3,5,7,11,13,17,23,29]
# primes.selected <-

▸

[]

✗

≡

Schleifen und Bedingte Anweisungen

Schleifen und bedingte Anweisungen

x = 0
for (i in 1:10) {
 x = x + i
 if (x> 10) x=x/2
 else x=x+1
}
print(x)

▸

[]

✗

≡

Aufgabe. Berechne die Summe eines Vektors

x = [1,2,3,4]
sum = 0
for (i in x) {
  # TODO
}
print(sum)

▸

[]

✗

≡

Datentabellen (Data Frames)

Datentabellen werden in R als data.frame mit der Funktion data.frame() erzeugt.
Es gibt auch Funktionen, wie z.B. das Lesen und Parsen einer CSV Datei, die Daten in Form eines data.frame objects erzeugen.
Häufig werden Datentabelle aus Spaltenvektoren oder Spaltenlisten erzeugt.

Erzeugung von Datentabellen (data.frame)

df <- data.frame(
  x = [1,2,3,4,5,6,7,8],
  y = [0,1,0,1,1,1,1,0]
)
print(df)

▸

[]

✗

≡

Es gibt eine Vielzahl von Operationen und Funktionen die man auf Datentabellen anwenden kann:

nrow, ncol, colnames und rownames liefern Informationen über die Tabelle;
colSums und rowSums liefern numerische Aggregate der Zeilen und Spalten
Die Selektion einer Zeile mittels df[row,] liefert eine Liste
Der Selektor df[row,] kann auch auf der linken Seite einer Zuweisung verwendet werden um eine bestehende Zeile zu ändern oder eine Zeile hinzuzufügren
Spalten können anhand der Spaltennamen ausgewählt werden (lesend und verändernd) via df$col oder df['colname'], ebenso können neue Spalten hinzugefügt werden

Aufgabe. Erzeuge eine Datentabelle mit den Spalten x,sin,cos,tan für die Werte x im bereich 0 bis 6 in den Abständen 0.5. Die Spalten sin,cos,tan sollen mit den mathematischen Funktionen programmatisch berechnet werden.

x <- [0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6]
# df ...
print(df)

▸

[]

✗

≡

Analyse eines Beispieldatensatzes

Daten

DATA: Variable dataIRIS Type: { length : number, width : number, petal.length : number, petal.width : number, species : string } [151]

Botanischer Standarddatensatz "iris"
Numerische Eingabevariablen (X)
Kategorische Ausgabevariable (Y)

Der Datensatz ist bereits im Notebook enthalten und wird als Datenrahmen (data.frame) data.iris zur Verfügung gestellt!

Arithmetik auf Datenvektoren

print(colnames(data.iris))
print(paste(nrow(data.iris),ncol(data.iris)))

▸

[]

✗

≡

Zerlgeung der Tabelle

Zerlegung in Spalten

x1 <- data.iris[,1]
x2 <- data.iris[,2]
x3 <- data.iris[,3]
x4 <- data.iris[,4]
y  <- data.iris[,5]
print(summary(x1))

▸

[]

✗

≡

Die Zielvariable y liegt als kategorische Variable vor. Eine Kodierung in eine numerische kann wie folgt mit der factor Funktion durchgeführt werden:

Kodierung

y.factor <- factor(y)
y.levels <- levels(y.factor)
y.code <- as.numeric(y.factor)
print(y.code)

▸

[]

✗

≡

Frage. Was enthält y.code? Was bewirkt factor (verwende print) und was enthält y.levels?

Analysefunktionen

Die universellste Analysefunktion ist summary, gefolgt von fivenum für numerische und table für kategorische Variablen.

Aufgabe. Analysiere den Datensatz mit 1. summary, 2. Einzelne Spalten mit fivenum und table. Welche Eigenschaften haben die einzelnen Variablen (Attribute)?

R summary liefert bei kategorischen Variablen keine Verteilungsanalyse. Mit dem Argument extended=TRUE kann diese hier aktivuiert werden.

Arithmetik auf Datenvektoren

# Analyse von data.iris
# summary(..,extended=TRUE)
# fivenum
# ...

▸

[]

✗

≡

Grafische Analyse

Die plot(x,y) Funktion ist universell und kann verschiedene Datenformate darstellen. Am häuigsten wird man sie für Punkt- und Linienverläufe verwenden. Die Breite (oder Höhe) des Plotfensters kann mit dev.new(width=300) gesetzt werden.

Beispiele für die Plot Funktion

x<-sapply((1:100),function (x) { sin(x/10) })
plot(x)
plot(x,x*x)

▸

[]

✗

≡

Aufgabe. Benutzte die plot(x,y) Funktion um Zusammenhänge zwischen den einzlenen Variablen x₁ bis x₄ und mit der Zielvariablen y.code herzustellen. Findet man Strukturen, können schon geeignete Kandidaten für die Klassifikation gefunden werden?

Grafische Analyse von Attributen

# plot(x1,x2) usw.

▸

[]

✗

≡

X-Y Partitionierung

Partitionierung der x-Werte nach (kategorischen) y-Werten

# Create x ~ y partitions for each attribute
x1.partitions <- list(A=x1[y==y.levels[1]],
                      B=x1[y==y.levels[2]],
                      C=x1[y==y.levels[3]])
x2.partitions <- list(A=x2[y==y.levels[1]],
                      B=x2[y==y.levels[2]],
                      C=x2[y==y.levels[3]])
x3.partitions <- list(A=x3[y==y.levels[1]],
                      B=x3[y==y.levels[2]],
                      C=x3[y==y.levels[3]])
x4.partitions <- list(A=x4[y==y.levels[1]],
                      B=x4[y==y.levels[2]],
                      C=x4[y==y.levels[3]])

▸

[]

✗

≡

Aufgabe. Analysiere die Partitionen. Lassen sich geeignete Teilungspunkte für wenigstens einer Zweiklassenseparation mit einer der Attribute erreichen?

Analyse der Partitionen

print(list(var="x1",
           A=range(x1.partitions$A),
           B=range(x1.partitions$B),
           C=range(x1.partitions$C)))
# x2 x3 x4

▸

[]

✗

≡

Hilfe

Einreichung (Assignment #01-46158 )

Prüfen

Bewerten (Lehrer)

Created by the NoteBook Compiler Ver. 1.25.0 (c) Dr. Stefan Bosse (Fri Dec 08 2023 17:25:09 GMT+0100 (Central European Standard Time))