Library

Was ist der Naive Bayes-Algorithmus?

Der Naive Bayes-Algorithmus ist ein probabilistischer Klassifikationsalgorithmus. Puh, schon ein schwieriger Ausdruck. Klassifikationsalgorithmus heißt aber nur, dass der Algorithmus Beobachtungen verschiedenen Klassen zuordnet. Und probabilistisch, dass es mit Wahrscheinlichkeiten zu tun hat. Denn der Naive Bayes-Algorithmus gibt uns für jede Klasse eine Wahrscheinlichkeit, dass die Beobachtung (x1,…,xn) zu dieser Klasse Ki gehört.

Mathematisch ausgedrückt:

Wenn wir genau sind, dann gibt es nicht den Naive Bayes-Algorithmus, sondern das beschreibt eine Klasse von Algorithmen, die alle auf dem gleichen Prinzip beruhen.

So, aber wie funktionieren die Algorithmen nun? Wie der Name vermuten lässt, hat es mit Bayes Theorem zu tun. Ich hole jetzt etwas aus, aber der Satz von Bayes ist wirklich wichtig und nicht so schwer zu verstehen.

Der Satz von Bayes

Bei dem Satz von Bayes geht es um bedingte Wahrscheinlichkeiten, also die Wahrscheinlichkeit eines Ereignisses A, wenn ein Ereignis B eingetreten ist. Man schreibt die Wahrscheinlichkeit dann als P( A | B ).

Der Satz von Bayes sagt:

Schauen wir uns das mal an einem Beispiel an. Nehmen wir an, wir machen einen medizinischen Test auf eine Krankheit. Der Test hat eine Sensitivität von 98%, d.h. die Wahrscheinlichkeit für ein positives Testergebnis gegeben die Krankheit beträgt 98%. Man sagt dazu auch die True-Positive-Rate. Zudem hat der Test eine Spezifität von 97%, d.h. die Wahrscheinlichkeit für ein negatives Testergebnis unter der Voraussetzung, dass man die Krankheit nicht hat, beträgt 97%. Das nennt man auch die True-Negative-Rate.

Wenn wir jetzt noch wissen, dass die Krankheit bei 1% der Bevölkerung vorkommt, können wir mit Hilfe des Satzes von Bayes ausrechnen, wie wahrscheinlich es ist, dass jemand tatsächlich die Krankheit hat, wenn der Test positiv ausfällt.

Die Wahrscheinlichkeit, krank zu sein, wenn der Test positiv ist, beträgt also nur knapp 25%. Das liegt vor allem an der geringen Wahrscheinlichkeit, überhaupt krank zu sein.

Jetzt kennen wir den Satz von Bayes. Und den wollen wir nutzen. Oben steht ja, dass der Algorithmus P(Ki | x1,…,xn) ausspucken soll. Das könnten wir doch nach dem Satz von Bayes umstellen.

Im Endeffekt interessiert uns nur der Zähler, da er gar nicht von der Klasse abhängt. P(Ki) ist die a priori Wahrscheinlichkeit, also eine Annahme, wie häufig die Klasse vorkommt. Um diese zu bestimmen, zählt man für gewöhnlich das Auftreten der einzelnen Klassen in einem Test-Datensatz. Man kann aber auch eine Gleichverteilung annehmen, d.h. jede Klasse ist a priori gleich wahrscheinlich.

Für den Naive Bayes-Algorithmus brauchen wir jetzt aber noch die zweite Zutat, die Naivität, damit wir weiterkommen.

Warum heißt der Naive Bayes-Algorithmus naiv?

Nein, der Algorithmus ist nicht simpel. Er benutzt einfach nur die „naive“ Annahme der bedingten Unabhängigkeit. Was heißt das konkret.

Wir hatten ja weiter oben die Gleichung P(Ki | x) = P(x| Ki) * P(Ki) ) / P(x). Der Zähler auf der rechten Seite entspricht der gemeinsamen Verteilung, also P(Ki, x1, …, xn). Und jetzt kommt die bedingte Unabhängigkeit ins Spiel: Wir treffen die Annahme, dass xj und xk gegeben Ki unabhängig sind. Das ist in der Realität zwar meistens nicht richtig, aber in der Praxis hat das erstaunlich wenig Einfluß. Damit wird P(Ki, x1, …, xn) zum Produkt der einzelnen Wahrscheinlichkeiten P(xj | Ki), j = 1, …, n

Nun fügen wir alles zusammen:

wobei nur ein Skalierungsfaktor ist.

Der Naive Bayes Algorithmus wählt nun die Klasse, die gegeben die Beobachtung x1, .., xn am wahrscheinlichsten ist. Statistisch sagt man dazu die maximale a-posteriori-Wahrscheinlichkeit. Das bedeutet, dass wir das k wählen, für das die Wahrscheinlichkeit maximal wird. Mathematisch ausgedrückt:

   

Finally: Das Event Model

Eine Sache fehlt noch. Wir müssen uns Gedanken machen, wie wir p(xj | Ki) bestimmen. Dazu gibt es verschiedene Annahmen über die Verteilung der Features

Gaussian Naive Bayes

Die zugrunde liegende Annahme ist, dass die x, die zu einer Klasse Ki gehören, normalverteilt sind. Damit das so sein kann, sollten die x natürlich erstmal metrisch sein.

Bestimmen wir also den Mittelwert mui und die Standardabweichung sigmai, dann können wir die Wahrscheinlichkeit einer bestimmten Ausprägung von x wie folgt berechnen:

   

Multinomial Naive Bayes

In diesem Fall ist die Annahme, dass eine multinomiale Verteilung zugrunde liegt, wie sie beim mehrmaligen Werfen eines k-seitigen Würfels. Eine Ausprägung des Features xj entspricht zum Beispiel der Häufigkeit des Auftretens eines Ereignisses j

   

Bernoulli Naive Bayes

In diesem Fall ist die Annahme, dass die Features x unabhängige binäre Variablen (ja/nein) sind, also zum Beispiel das Auftauchen einer bestimmten Eigenschaft

   

Beispiele für Naive Bayes in R

In R gibt es meines Wissens zwei Packages, die Naive Bayes implementiert haben. Das ist zum einen das Package e1071, welches eine ganze Reihe statistische Methoden wie support vector machines und eben auch Naive Bayes implementiert hat. Zum anderen gibt es das Package NaiveBayes, welches ich hier benutze.

Die Anwendung des Naive Bayes-Algorithmus ist ganz einfach in einer Zeile gemacht. Man braucht aber natürlich ein bisschen Code drumherum.

Im ersten Beispiel ziehen wir 1000x aus der Standardnormalverteilung und ordnen den Wert einer Klasse (TRUE) zu, wenn der Wert größer als 0 ist. Andernfalls gehört er zur anderen Klasse (FALSE).

Den Datensatz splitten wir zufällig in einen Trainingsdatensatz und einen Testdatensatz, wobei der Trainingsdatensatz 80% des gesamten Datensatzes umfasst.

#sofern noch nicht installiert, einmalig das Package herunterladen und installieren
#install.packages("naivebayes")

library(naivebayes)

## 1. Beispiel: Normalverteilung positiv ##############################
n <- 1000
trainsize <- 0.8 * n
set.seed(1)
df <- data.frame(ID=1:n,x=rnorm(n))
df$Klasse <- ifelse(df$x>0,TRUE,FALSE)

#Split in Trainings- und Testdatensatz
trainRows <- sample(n, trainsize, replace = FALSE)
train <- df[trainRows,]
test <- df[setdiff(1:n,trainRows),]

12345678910111213141516

#sofern noch nicht installiert, einmalig das Package herunterladen und installieren#install.packages("naivebayes") library(naivebayes) ## 1. Beispiel: Normalverteilung positiv ##############################n <- 1000trainsize <- 0.8 * nset.seed(1)df <- data.frame(ID=1:n,x=rnorm(n))df$Klasse <- ifelse(df$x>0,TRUE,FALSE)  #Split in Trainings- und TestdatensatztrainRows <- sample(n, trainsize, replace = FALSE)train <- df[trainRows,]test <- df[setdiff(1:n,trainRows),]

Nachdem wir dann den Naive Bayes-Algorithmus darauf losgelassen haben, überprüfen wir am Testdatensatz, wie gut er funktioniert hat. Dazu lassen wir den Testdatensatz anhand predict klassifizieren und schauen uns die Kontingenztafel an und berechnen die Accuracy, also den Anteil an richtig zugeordneten Klassen.

# Naive Bayes
nb <- naive_bayes(Klasse ~ x, data = train)

# Vorhersage auf Testdatensatz
test$predicted <- predict(nb,test)
Kontingenztafel <- table(test[,c("Klasse","predicted")])
Kontingenztafel
Accuracy <- (Kontingenztafel[1,1] + Kontingenztafel[2,2])/sum(Kontingenztafel)
sprintf("Accuracy: %1.1f%%", 100*Accuracy)

## 2. Beispiel: Klassifikation des Iris-Datensatzes ###################
trainRows <- sample(nrow(iris), nrow(iris)*0.8, replace = FALSE)
train <- iris[trainRows,]
test <- iris[setdiff(1:nrow(iris),trainRows),]

# Naive Bayes
nb <- naive_bayes(Species ~ ., train)

# Vorhersage auf Testdatensatz
test$predicted <- predict(nb,test)
Kontingenztafel <- table(test[,c("Species","predicted")])
Kontingenztafel
Accuracy <- sum(diag(Kontingenztafel))/sum(Kontingenztafel)
sprintf("Accuracy: %1.1f%%", 100*Accuracy)

123456789101112131415161718192021222324

# Naive Bayesnb <- naive_bayes(Klasse ~ x, data = train) # Vorhersage auf Testdatensatztest$predicted <- predict(nb,test)Kontingenztafel <- table(test[,c("Klasse","predicted")])KontingenztafelAccuracy <- (Kontingenztafel[1,1] + Kontingenztafel[2,2])/sum(Kontingenztafel)sprintf("Accuracy: %1.1f%%", 100*Accuracy) ## 2. Beispiel: Klassifikation des Iris-Datensatzes ###################trainRows <- sample(nrow(iris), nrow(iris)*0.8, replace = FALSE)train <- iris[trainRows,]test <- iris[setdiff(1:nrow(iris),trainRows),]    # Naive Bayesnb <- naive_bayes(Species ~ ., train) # Vorhersage auf Testdatensatztest$predicted <- predict(nb,test)Kontingenztafel <- table(test[,c("Species","predicted")])KontingenztafelAccuracy <- sum(diag(Kontingenztafel))/sum(Kontingenztafel)sprintf("Accuracy: %1.1f%%", 100*Accuracy)

Wir sehen, dass Naive Bayes dieses Beispiel sehr gut vorhersagt. Die Accuracy liegt bei 98,5%

Vorhersage (predict)
TRUEFALSE
Test-DatensatzTRUE1010
FALSE396
Im zweiten Beispiel benutzen wir den Iris-Datensatz, der mit R mitgeliefert wird und ein beliebter Anschauungsdatensatz für zahlreiche Beispiele ist.

Wie im ersten Beispiel splitten wir wieder zufällig in Trainings- und Testdatensatz. Dann wollen wir die drei Arten (Species) anhand der anderen Variablen mittels Naive Bayes klassifizieren. Das wenden wir dann auf den Testdatensatz an und schauen uns an, wie gut der Algorithmus war

## 2. Beispiel: Klassifikation des Iris-Datensatzes ###################
trainRows <- sample(nrow(iris), nrow(iris)*0.8, replace = FALSE)
train <- iris[trainRows,]
test <- iris[setdiff(1:nrow(iris),trainRows),]

# Naive Bayes
nb <- naive_bayes(Species ~ ., train)

# Vorhersage auf Testdatensatz
test$predicted <- predict(nb,test)
Kontingenztafel <- table(test[,c("Species","predicted")])
Kontingenztafel
Accuracy <- sum(diag(Kontingenztafel))/sum(Kontingenztafel)
sprintf("Accuracy: %1.1f%%", 100*Accuracy)

1234567891011121314

## 2. Beispiel: Klassifikation des Iris-Datensatzes ###################trainRows <- sample(nrow(iris), nrow(iris)*0.8, replace = FALSE)train <- iris[trainRows,]test <- iris[setdiff(1:nrow(iris),trainRows),]    # Naive Bayesnb <- naive_bayes(Species ~ ., train) # Vorhersage auf Testdatensatztest$predicted <- predict(nb,test)Kontingenztafel <- table(test[,c("Species","predicted")])KontingenztafelAccuracy <- sum(diag(Kontingenztafel))/sum(Kontingenztafel)sprintf("Accuracy: %1.1f%%", 100*Accuracy)

Hier ist Naive Bayes sogar perfekt. Die Accuracy liegt bei 100%, es wurden alle Arten korrekt klassifiziert.

Vorhersage (predict)
SetosaVersicolorVirginica
Test-DatensatzSetosa1000
Versicolor0120
Virginica008
So, jetzt könnt ihr selber loslegen. Schnappt euch einen interessanten Datensatz, schmeißt den Naive Bayes-Algorithmus drauf und schaut, wie gut er abschneidet. So bekommt ihr auch ein Gefühl dafür, wann er gut geeignet ist und wann eher nicht so.
Glossar: rnorm

Master of Time: Datum und Zeitstempel in R

In diesem R-Artikel geht es darum, wie
ihr in R mit Datums- und Zeitangaben umgeht. Dafür hat R drei Datentypen
vorgesehen, nämlich Date für ein Datum und POSIXct bzw. POSIXlt für
Zeitstempel, also Datum plus Zeitangabe. Reine Zeitangaben, also nur die Uhrzeit
ohne Datum, sind eher selten und nicht sehr praktikabel.

Ich zeige euch, wie ihr Strings oder
Zahlen in einen der Datentypen überführt und damit rechnen könnt. Für ein
besseres Handling ist das Package “lubridate” aus dem tidyverse super geeignet.
Dazu aber weiter unten mehr, wir fangen mit Standard-R an.

Der Datumstyp in R

heute <- Sys.Date()
print(heute)
## [1] "2019-02-23"
jetzt <- Sys.time()
print(jetzt)
## [1] "2019-02-23 08:34:00 CET"

typeof(heute)
## [1] "double"
typeof(jetzt)
## [1] "double"

str(heute)
## Date[1:1],
format: "2019-02-23"
str(jetzt)
## POSIXct[1:1],
format: "2019-02-23 08:34:00"

123456789101112131415161718

heute <- Sys.Date()print(heute)## [1] "2019-02-23"jetzt <- Sys.time()print(jetzt)## [1] "2019-02-23 08:34:00 CET" typeof(heute)## [1] "double"typeof(jetzt)## [1] "double" str(heute)## Date[1:1],format: "2019-02-23"str(jetzt)## POSIXct[1:1],format: "2019-02-23 08:34:00"

Wir sehen also, dass sowohl Datum als
auch Zeitstempel intern als Zahl gespeichert werden, nämlich als Anzahl Tage
(Date) oder Sekunden (POSIX) seit einem festgelegten Startdatum, nämlich seit
dem 1. Januar 1970 00:00 UTC. Als Zusatz wird aber doch noch abgespeichert,
dass es sich um ein Datum oder Zeitstempel handelt. Das sehen wir an der
Struktur (str). Sonst würde die print-Funktion ja auch nur eine Zahl ausgeben
und nicht automatisch in einen String umwandeln.

print(as.numeric(heute))
## [1] 17950
print(as.numeric(jetzt))
## [1] 1550907241

# ein Datum kann als Anzahl Tage seit einem
Upsprungsdatum angegeben werden
d <- as.Date(1,origin="1970-01-01")
print(as.numeric(d))
## [1] 1

12345678910

print(as.numeric(heute))## [1] 17950print(as.numeric(jetzt))## [1] 1550907241 # ein Datum kann als Anzahl Tage seit einemUpsprungsdatum angegeben werdend <- as.Date(1,origin="1970-01-01")print(as.numeric(d))## [1] 1

Datum aus String

Wollen wir ein Datum aus einem String
erzeugen, können wir entweder die Standardformate verwenden, die in R
YYYY-MM-DD und YYYY/MM/DD sind. Ansonsten müssen wir mit dem Parameter format angeben, welches Format wir
übergeben. Dabei gibt es einige Kürzel, die alle mit % anfangen. In der Liste
unten findet ihr sie. Um aus einem Datum wieder einen String zu machen, könnt
ihr die Funktion format benutzen.

d1 <- as.Date("2018-02-22")
d2 <- as.Date("20.02.2018",format="%d.%m.%Y")
d3 <- as.Date("02/18/18",format="%m/%d/%y")

format(d1,"%d.%m.%Y")
## [1] "22.02.2018"
format(d2,"%d.%m.%Y")
## [1] "20.02.2018"

12345678

d1 <- as.Date("2018-02-22")d2 <- as.Date("20.02.2018",format="%d.%m.%Y")d3 <- as.Date("02/18/18",format="%m/%d/%y") format(d1,"%d.%m.%Y")## [1] "22.02.2018"format(d2,"%d.%m.%Y")## [1] "20.02.2018"

Kürzel

Beschreibung

Beispiel

%m

Monat (01-12)

05

%b or %h

3-stelliger Monatsname

Feb

%B

Monatsname

Februar

%d

Tag des Monats (01-31)

27

%j

Tag vom Jahr (001-366)

148

%y

2-stelliges Jahr (00-99)

18

%Y

4-stelliges Jahr

2018

%C

Jahrhundert

20

%x

Datum (System)

 

%D

Datum MM/TT/JJJJ

05/27/84

%U

Kalenderwoche, Sonntag=erster Tag der Woche
(01-53)

22

%W

Kalenderwoche, Montag=erster Tag der Woche
(00-53)

22

%u

Wochentag, Montag=1 (1-7)

7

%w

Wochentag, Sonntag=0 (0-6)

0

%a

3-stelliger Wochentag

So

%A

Wochentag

Donnerstag
Und so sieht das dann im Code aus:

d <- as.Date("2018-02-22")
print(paste("Monat:",format(d,"%m")))
## [1] "Monat: 02"
print(paste("3-stelliger Monatsname:",format(d,"%b")))
## [1] "3-stelliger Monatsname: Feb"
print(paste("Monatsname:",format(d,"%B")))
## [1] "Monatsname: Februar"
print(paste("Tag:",format(d,"%d")))
## [1] "Tag: 22"
print(paste("Tag vom Jahr:",format(d,"%j")))
## [1] "Tag vom Jahr: 053"
print(paste("2-stelliges Jahr:",format(d,"%y")))
## [1] "2-stelliges Jahr: 18"
print(paste("4-stelliges Jahr:",format(d,"%Y")))
## [1] "4-stelliges Jahr: 2018"
print(paste("Jahrhundert:",format(d,"%C")))
## [1] "Jahrhundert: 20"
print(paste("Kalenderwoche (US):",format(d,"%U")))
## [1] "Kalenderwoche (US): 07"
print(paste("Kalenderwoche (DE):",format(d,"%W")))
## [1] "Kalenderwoche (DE): 08"
print(paste("Datum (Systemeinstellung):",format(d,"%x")))
## [1] "Datum (Systemeinstellung): 22.02.2018"
print(paste("Datum MM/TT/JJJJ:",format(d,"%D")))
## [1] "Datum MM/TT/JJJJ: 02/22/18"
print(paste("Wochentag (Montag=1):",format(d,"%u")))
## [1] "Wochentag (Montag=1): 4"
print(paste("Wochentag (Sonntag=0):",format(d,"%w")))
## [1] "Wochentag (Sonntag=0): 4"
print(paste("3-stelliger Tagesname:",format(d,"%a")))
## [1] "3-stelliger Tagesname: Do"
print(paste("Tagesname:",format(d,"%A")))
## [1] "Tagesname: Donnerstag"

123456789101112131415161718192021222324252627282930313233

d <- as.Date("2018-02-22")print(paste("Monat:",format(d,"%m")))## [1] "Monat: 02"print(paste("3-stelliger Monatsname:",format(d,"%b")))## [1] "3-stelliger Monatsname: Feb"print(paste("Monatsname:",format(d,"%B")))## [1] "Monatsname: Februar"print(paste("Tag:",format(d,"%d")))## [1] "Tag: 22"print(paste("Tag vom Jahr:",format(d,"%j")))## [1] "Tag vom Jahr: 053"print(paste("2-stelliges Jahr:",format(d,"%y")))## [1] "2-stelliges Jahr: 18"print(paste("4-stelliges Jahr:",format(d,"%Y")))## [1] "4-stelliges Jahr: 2018"print(paste("Jahrhundert:",format(d,"%C")))## [1] "Jahrhundert: 20"print(paste("Kalenderwoche (US):",format(d,"%U")))## [1] "Kalenderwoche (US): 07"print(paste("Kalenderwoche (DE):",format(d,"%W")))## [1] "Kalenderwoche (DE): 08"print(paste("Datum (Systemeinstellung):",format(d,"%x")))## [1] "Datum (Systemeinstellung): 22.02.2018"print(paste("Datum MM/TT/JJJJ:",format(d,"%D")))## [1] "Datum MM/TT/JJJJ: 02/22/18"print(paste("Wochentag (Montag=1):",format(d,"%u")))## [1] "Wochentag (Montag=1): 4"print(paste("Wochentag (Sonntag=0):",format(d,"%w")))## [1] "Wochentag (Sonntag=0): 4"print(paste("3-stelliger Tagesname:",format(d,"%a")))## [1] "3-stelliger Tagesname: Do"print(paste("Tagesname:",format(d,"%A")))## [1] "Tagesname: Donnerstag"

Rechnen mit Daten

d1 <- as.Date("2018-01-23")
d2 <- as.Date("2018-02-22")
delta <- d2 - d1
delta
## Time difference of 30 days
str(delta)
## 'difftime' num
30
## - attr(*,"units")= chr "days"
attributes(delta)
## $class
## [1] "difftime"
##
## $units
## [1] "days"
difftime(d2,d1,units="weeks")
## Time difference of 4.285714 weeks

#erster Tag des Monats
Tage <- as.numeric(format(d1,"%d")) - 1
as.Date(-Tage,d1)
## [1] "2018-01-01"

ersterTagDesMonats <- function(Datum) {
return(as.Date(-as.numeric(format(Datum,"%d")) + 1,Datum))
}
ersterTagDesMonats(d2)
## [1] "2018-02-01"

12345678910111213141516171819202122232425262728

d1 <- as.Date("2018-01-23")d2 <- as.Date("2018-02-22")delta <- d2 - d1delta## Time difference of 30 daysstr(delta)## 'difftime' num30## - attr(*,"units")= chr "days"attributes(delta)## $class## [1] "difftime"## ## $units## [1] "days"difftime(d2,d1,units="weeks")## Time difference of 4.285714 weeks #erster Tag des MonatsTage <- as.numeric(format(d1,"%d")) - 1as.Date(-Tage,d1)## [1] "2018-01-01" ersterTagDesMonats <- function(Datum) {    return(as.Date(-as.numeric(format(Datum,"%d")) + 1,Datum))}ersterTagDesMonats(d2)## [1] "2018-02-01"

Datum mit dem
Package lubridate

Viel einfacher geht das alles mit dem
Package lubridate. Wie bei jedem
Packages muss es einmal installiert werden install.packages(“lubridate”).
Danach kann es mit library(lubridate) oder require(lubridate) im Skript geladen werden.

Lubridate hat einige Funktionen, um
schnell ein Datum zu erzeugen, an die einzelnen Teile heranzukommen und auch
diese abzuändern

library(lubridate)
##
## Attaching package: 'lubridate'
## The following object is masked from 'package:base':
##
## date

# Ein Datum erstellen
d <- ymd(20180514)
d2 <- mdy("4/1/17")

# Abruf der einzelnen Teile
year(d)
## [1] 2018
month(d)
## [1] 5
day(d)
## [1] 14
wday(d)
## [1] 2
wday(d,label=TRUE)
## [1] Mo
## Levels: So < Mo < Di < Mi < Do < Fr < Sa
wday(d,label=TRUE,abbr=FALSE)
## [1] Montag
## 7 Levels: Sonntag < Montag < Dienstag < Mittwoch < ... < Samstag
wday(d,label=TRUE,abbr=FALSE,week_start=1)
## [1] Montag
## 7 Levels: Montag < Dienstag < Mittwoch < Donnerstag < ... < Sonntag
yday(d)
## [1] 134

# Modifikation
month(d) <- 2
day(d) <- 5
d
## [1] "2018-02-05"

12345678910111213141516171819202122232425262728293031323334353637

library(lubridate)## ## Attaching package: 'lubridate'## The following object is masked from 'package:base':## ##      date # Ein Datum erstellend <- ymd(20180514)d2 <- mdy("4/1/17") # Abruf der einzelnen Teileyear(d)## [1] 2018month(d)## [1] 5day(d)## [1] 14wday(d)## [1] 2wday(d,label=TRUE)## [1] Mo## Levels: So < Mo < Di < Mi < Do < Fr < Sawday(d,label=TRUE,abbr=FALSE)## [1] Montag## 7 Levels: Sonntag < Montag < Dienstag < Mittwoch < ... < Samstagwday(d,label=TRUE,abbr=FALSE,week_start=1)## [1] Montag## 7 Levels: Montag < Dienstag < Mittwoch < Donnerstag < ... < Sonntagyday(d)## [1] 134 # Modifikationmonth(d) <- 2day(d) <- 5d## [1] "2018-02-05"

Als nützlich haben sich auch die
Rundungsfunktionen in lubridate erwiesen. Mit diesen kann zum Beispiel der
Monatsanfang leicht bestimmt werden.

# springt zum Anfang des Monats
floor_date(d,unit="month")
## [1] "2018-02-01"
# springt zum Anfang des nächsten Monats
ceiling_date(d,unit="month")
## [1] "2018-03-01"
# rundet auf Monate, also bis zum 14. zum Monatsanfang, ab dem 15. zum nächsten Monatsanfang
round_date(d,unit="month")
## [1] "2018-02-01"
round_date(d+1,unit="month")
## [1] "2018-02-01"

1234567891011

# springt zum Anfang des Monatsfloor_date(d,unit="month")## [1] "2018-02-01"# springt zum Anfang des nächsten Monatsceiling_date(d,unit="month")## [1] "2018-03-01"# rundet auf Monate, also bis zum 14. zum Monatsanfang, ab dem 15. zum nächsten Monatsanfanground_date(d,unit="month")## [1] "2018-02-01"round_date(d+1,unit="month")## [1] "2018-02-01"

Zeitstempel

Ein Zeitstempel setzt sich aus Datum
und Uhrzeit zusammen. Für eine richtige Uhrzeit ist noch die Zeitzone
angegeben, damit es eindeutig wird. Der entsprechende Datentyp in R ist POSIXct
bzw. POSIXlt. Diese beiden unterscheiden sich in der internen Darstellung.
POSIXct speichert die Anzahl Sekunden seit dem Origin (UNIX Epoch, nämlich der
01.01.1970 00:00:00), POSIXlt speichert eine Liste mit Tag, Monat, Jahr,
Stunde, Minute, etc.

Damit kann man mittels Attributen auf
Teile eines POSIXlt zugreifen, beim POSIXct muss man über format den entsprechenden Wert extrahieren und dann gegebenenfalls
noch in eine Zahl umwandeln. Mit dem Package lubridate läßt sich das
vereinfachen, in dem per Funktion direkt auf die einzelnen Teile zugreifen
kann, dazu weiter unten mehr.

# die aktuelle Systemzeit wird als POSIXct zurückgegeben
jetzt <- Sys.time()
str(jetzt)
##&nbsp; POSIXct[1:1], format: "2019-02-23 08:34:01"
attributes(jetzt)
## $class
## [1] "POSIXct" "POSIXt"
#gibt die Minuten aus
as.numeric(format(jetzt,"%M"))
## [1] 34

# mit as.POSIXlt kann sie in ein POSIXlt umgewandelt werden
jetzt_lt <- as.POSIXlt(jetzt)
str(jetzt_lt)
## POSIXlt[1:1],format: "2019-02-23 08:34:01"
attributes(jetzt_lt)
## $names
## [1] "sec" "min" "hour" "mday" "mon" "year" "wday"
## [8] "yday" "isdst" "zone" "gmtoff"
##
## $class
## [1] "POSIXlt" "POSIXt"
##
## $tzone
## [1] "" "CET" "CEST"
jetzt_lt$min
## [1] 34

# origin und tz (timezone) sind optional, also nur nötig, wenn nicht der Standardwert genommen werden soll
ts <- as.POSIXct("20190222105519", format="%Y%m%d%H%M%S", origin="1970-01-01", tz="CET")
ts
## [1] "2019-02-22 10:55:19 CET"
ts2 <- as.POSIXct("22.02.2019 10:55:19", format="%d.%m.%Y %H:%M:%S")
ts2
## [1] "2019-02-22 10:55:19 CET"

123456789101112131415161718192021222324252627282930313233343536

# die aktuelle Systemzeit wird als POSIXct zurückgegebenjetzt <- Sys.time()str(jetzt)##&nbsp; POSIXct[1:1], format: "2019-02-23 08:34:01"attributes(jetzt)## $class## [1] "POSIXct" "POSIXt"#gibt die Minuten ausas.numeric(format(jetzt,"%M"))## [1] 34 # mit as.POSIXlt kann sie in ein POSIXlt umgewandelt werdenjetzt_lt <- as.POSIXlt(jetzt)str(jetzt_lt)##  POSIXlt[1:1],format: "2019-02-23 08:34:01"attributes(jetzt_lt)## $names## [1] "sec"   "min"   "hour"  "mday"  "mon"  "year"  "wday"## [8] "yday"  "isdst" "zone"  "gmtoff"## ## $class## [1] "POSIXlt" "POSIXt"## ## $tzone## [1] ""   "CET"   "CEST"jetzt_lt$min## [1] 34  # origin und tz (timezone) sind optional, also nur nötig, wenn nicht der Standardwert genommen werden sollts <- as.POSIXct("20190222105519", format="%Y%m%d%H%M%S", origin="1970-01-01", tz="CET")ts## [1] "2019-02-22 10:55:19 CET"ts2 <- as.POSIXct("22.02.2019 10:55:19", format="%d.%m.%Y %H:%M:%S")ts2## [1] "2019-02-22 10:55:19 CET"

Neben den Datumskürzelns aus der
obigen Tabelle können wir mit den folgenden Kürzeln noch die Zeit definieren.
Das funktioniert sowohl bei der Erzeugung aus einem String als auch der
umgekehrte Weg mittels format.

Kürzel

Beschreibung

Beispiel

%c

Zeitstempel im System-Format

Fr Feb 22 10:55:19 2019

%H

Stunden (00-24)

23

%I

Stunden (00-12)

11

%M

Minuten

55

%p

AM/PM (sofern verwendet)

AM

%S

Decimal second

19

%X

Zeit (Systemeinstellungen)

HH:MM:SS

%z

Abweichung von GMT

+0100

%Z

Zeitzone

CET

format(ts,"%c")
## [1] "Fr Feb 22 10:55:19 2019"
format(ts,"%H")
## [1] "10"
format(ts,"%I")
## [1] "10"
format(ts,"%M")
## [1] "55"
format(ts,"%p")
## [1] ""
format(ts,"%S")
## [1] "19"
format(ts,"%X")
## [1] "10:55:19"
format(ts,"%z")
## [1] "+0100"
format(ts,"%Z")
## [1] "CET"

123456789101112131415161718

format(ts,"%c")## [1] "Fr Feb 22 10:55:19 2019"format(ts,"%H")## [1] "10"format(ts,"%I")## [1] "10"format(ts,"%M")## [1] "55"format(ts,"%p")## [1] ""format(ts,"%S")## [1] "19"format(ts,"%X")## [1] "10:55:19"format(ts,"%z")## [1] "+0100"format(ts,"%Z")## [1] "CET"

Um die Zeitspanne zwischen zwei
Zeitstempeln zu bestimmen, können wir sie einfach voneinander abziehen. Das
Problem ist aber, dass wir dann die Einheit (Tage, Stunden, …) nicht selber
wählen können. Daher ist es besser, dass über difftime zu machen und den
Parameter units explizit zu setzen.

delta <- Sys.time() - ts
str(delta)
## 'difftime' num
21.6450349113676
## - attr(*,"units")= chr "hours"
delta <- difftime(Sys.time() , ts, units="days")

123456

delta <- Sys.time() - tsstr(delta)##  'difftime' num21.6450349113676##  - attr(*,"units")= chr "hours"delta <- difftime(Sys.time() , ts, units="days")

Zeitstempel mit
lubridate

Zeittempel mit lubridate funktionieren
ganz genauso wie wir das oben schon beim Datum gesehen haben. Es gibt
Erzeuger-Funktionen wie ymd_hms und
Funktionen, die die einzelnen Teile des Zeitstempels extrahieren. Ordnet man
diesen Extraktionsfunktionen einen Wert zu, wird der Zeitstempel geändert.

library(lubridate)
ts <- ymd_hms("2011-06-04 12:00:00")
year(ts)
## [1] 2011
hour(ts)
## [1] 12
second(ts)
## [1] 0

second(ts) <- 25
ts
## [1] "2011-06-04 12:00:25 UTC"

123456789101112

library(lubridate)ts <- ymd_hms("2011-06-04 12:00:00")year(ts)## [1] 2011hour(ts)## [1] 12second(ts)## [1] 0 second(ts) <- 25ts## [1] "2011-06-04 12:00:25 UTC"

So, ich hoffe, jetzt seid ihr zum Master of Date and Time geworden.
Glossar: rnorm min

Kann man eine KI entwickeln, die ohne langes Training etwas lernt?

Das ist tatsächlich ein sehr spannendes Forschungsfeld, das
viele Leute umtreibt. Die KI-Technik, aus wenigen Beispiel zu lernen, nennt
sich übrigens One-Shot-Learning. Und in dieser Technik ist der Mensch dem
Computer noch haushoch überlegen. Der Mensch kann anscheinend sehr gut
vorheriges Wissen auf neue Kategorien übertragen.

Die Vorteile liegen auf der Hand. Denn mit vielen der
aktuellen Methoden braucht man einen sehr großen Datensatz für das Training.
Diesen Datensatz zu erstellen ist meistens teuer und zeitaufwendig. Zudem wird
dann teure Rechenkapazität benötigt, um diese vielen Daten in das Modell zu
schleusen. Wenn man an seltene Krankheiten denkt, dann gibt es mitunter auch
gar keinen genügend großen Datensatz.

Warum brauchen wir aktuell noch so große Trainingssets?

Die meisten KI-Algorithmen basieren auf statistischen
Verfahren und haben, wenn sie komplex genug sind, einen Haufen Parameter, die
anhand des Trainings optimiert werden. Wer schon mal lineare Regression in der
Praxis eingesetzt hat, weiß, dass die Anzahl Datenpunkte mit der Anzahl
Prädiktoren massiv steigt.

Die aktuell populärste KI-Algorithmenklasse sind künstliche
Neuronale Netze. Ein neuronales Netz besteht aus mehreren Schichten, also einer
Eingangsschicht, gefolgt von mehreren Zwischenschichten (sogenannte hidden
layers) und einer Ausgangsschicht. Jede Schicht besteht aus mehreren Knoten
(den Neuronen). Die Knoten zweier aufeinander folgende Schichten sind alle
miteinander verbunden und jede dieser Verbindungen hat ein Gewicht. Nun werden
diese Gewichte anhand der Trainingsdaten so angepasst, dass das neuronale Netz
die gestellte Aufgabe hoffentlich gut erledigt.

Die Eingangsschicht hat für jedes Feature ein Neuron, also
zum Beispiel die Anzahl Pixel eines Bildes. Die Ausgangsschicht hat so viele
Neuronen wie eben Entscheidungen/Handlungen möglich sind, z.B. zwei bei einer
binären Klassifikation: ja und nein. Über die Anzahl Zwischenschichten und deren
Anzahl Neuronen gibt es keine allgemeingültige Aussage. Es gibt Paper, die
sagen, dass für die meisten Probleme eine Zwischenschicht genügt und dass die
Anzahl Neuronen zwischen der Anzahl Neuronen der Ausgangs- und der
Eingangsschicht liegen.

Nehmen wir das populäre Beispiel der handschriftlichen
Ziffernerkennung anhand der MNIST Datenbank. Ein sogenanntes Convolutional
Neural Network (CNN), das sehr gut abgeschnitten hat (Fehlerrate von 0,27%)
besteht insgesamt aus 7 Schichten mit den folgenden Anzahl Neuronen:
784-50-100-500-1000-10-10. Das sind also gigantische 604.300 Verbindungen, die
einen Gewichtsparamter haben. Die Fehlerrate konnte durch die Kombination von
mehreren CNNs noch reduziert werden.

Es gibt also eine riesige Menge Gewichte, die alle bestimmt
werden wollen. Und dafür braucht man diese riesige Anzahl Trainingsbeispiele

Und was ist jetzt One-Shot-Learning?

Wie der Begriff schon sagt, soll mittels eines Versuchs
gelernt werden. Der Name ist allerdings ein bisschen irreführend, denn beim
One-Shot-Learning geht es nicht zwingend darum, aus nur einem einzigen Beispiel
zu lernen. Das wäre zwar besonders wünschenswert, aber realistischerweise
braucht die KI doch einige wenige Trainingsdaten.

Wie soll das funktionieren? Dazu nehmen wir uns den Menschen
zum Vorbild, der die Fähigkeit besitzt das Lernen zu lernen. In der KI-Welt
bezeichnet man das als Meta-Learning.

Was ist Meta-Learning? Ein Gedächtnis muss her!

Die Idee hinter Meta-Learning ist, dass wir schon gelerntes
auf neue Situationen übertragen, also eine Art Wissenstransfer. Dabei können
wir drei Arten unterscheiden:

Wissenstransfer
durch Modellparameter: Der Startpunkt für das Training einer neuen Klasse
sind die aus früheren Trainings gelernten Modellparameter.Wissenstransfer
durch gemeinsame Features: Die Features, die die neue als auch die alte
Klasse besitzen, werden als Ausgangspunkt genommen. Wenn ein Algorithmus
gelernt hat, eine Kuh zu erkennen, dann kann er davon ausgehend schnell lernen,
auch ein Pferd zu erkennen. Wissenstransfer
durch Kontext: Hierbei geht es darum, das Setting mit einzubeziehen, also
zum Beispiel von dem perfekten Bilder-Datensatz, welcher auf das zu erkennende
Motiv  zugeschnitten und gedreht wurde,
zu realistischeren Bildern überzugehen, welche das Motiv zur enthalten.Alle drei müssen auf bereits Gelerntes zugreifen können.
Dafür ist eine Art Gedächtnis nötig. Man könnte allgemein sagen, dass
Meta-Learning ein langwieriger Prozess ist, der durch Erweiterung des Wissens
immer mehr lernt. One-Shot-Learning ist davon also nur der Teil, neues Wissen
aus bestehendem Wissen und einigen Beispielen zu generieren.

Was sind Memory-Augmented Neural Networks?

Eine Klasse Neuronaler Netze, welche eine Art Meta-Learning
implementieren, sind die sogenannten Memory-Augmented Neural Networks (MANN). Diese
sind eine Weiterentwicklung bzw. eher eine Vereinfachung von Neural Turing
Machines (NTM) und bestehen aus einem Controller, welcher ein Neuronales Netz
ist, sowie einem Speicher besteht. Der Controller muss, wie der Name sagt,
alles koordinieren, also je nach Inputs Inhalte aus dem Speicher auslesen, modifizieren
oder neu schreiben. Und am Ende muss der Controller natürlich zu einem Ergebnis
kommen.

Wer mehr darüber erfahren will, liest sich am besten in das
Paper „One-Shot-Learning with
Memory-Augmented Neural Networks“ ein.

Funktionieren MANNs für One-Shot-Learning?

Die ersten Ergebnisse sehen vielversprechend aus. So wurde
der Omniglot Datensatz verwendet, der aus Buchstaben bzw. Symbolen
verschiedener Sprachen besteht, um zu lernen, das Symbol einer Sprache
zuzuordnen. Dabei gibt es jeweils nur wenige Beispiele einer Sprache.

Dabei schnitt das Memory-Augmented Neural Network mit einem
LSTM Neuronales Netz (Long Short Term Memory) als Controller besser ab als das reine
LSTM Netz.
Glossar: rnorm min Neuronales Netz

Wie erklärt man einem Kind, wie maschinelles Lernen funktioniert?

Es kommt natürlich ein bisschen darauf an, wie alt das Kind
ist. Eine eingängige Beschreibung ist, dass Computerprogramme bestimme Aufgaben
erledigen können, ohne dass ihnen ganz genau gesagt wurde, wie sie die Aufgabe
erledigen. Wie ein Mensch lernt das Computerprogramm durch Wiederholung und Übung.

Aber vermutlich ist es am einfachsten, anhand von Beispielen
zu erklären, was maschinelles Lernen ist:

Beispiel 1: Bilderkennung durch den Computer

Ein Computerprogramm soll erkennen, ob ein Hund auf einem Bild ist. Dazu wurde das Programm trainiert, indem ihm ganz viele Bilder mit und ohne Hunde gezeigt und dabei gesagt wurde, ob ein Hund auf dem Bild war. Dadurch hat das Programm gelernt, Bilder mit und ohne Hunde zu unterscheiden.

Beispiel 2: Schach spielen

Computerprogramme können im Schach die besten
Schach-Großmeister besiegen. Dazu wurde dem Computerprogramm zum einen beigebracht,
welche Züge erlaubt sind. Zum anderen greift das Programm auf eine riesige
Bibliothek von gespielten Schachpartien zurück, um zu entscheiden, was aktuell
der bestmögliche Zug ist. Vor nicht allzu langer Zeit hat man einem
Computerprogramm sogar nur die Regeln einprogrammiert und es dann ganz oft gegen
sich selbst spielen lassen.

Das funktioniert auch für andere Spiele. Es gibt sogar
Computerprogramme, die Computerspiele besser als Menschen spielen können.

Beispiel 3: Sprachsteuerung durch maschinelles Lernen

Damit man dem Computer nicht mit Maus, Tastatur oder dem
Touchscreen befehlen muss, was er tun soll, erkennen Computer mittlerweile
unsere Sprache. Das ist zum Beispiel im Auto sehr nützlich, wenn man ein Lied
hören möchte, aber die Hände besser am Lenkrad behält. Aber auch sonst ist es
viel bequemer, dem Computer nur zu sagen „Computer, spiele das Lied xy“ anstatt
den Liedtitel eintippen zu müssen.

Der Computer muss nicht nur verschiedene Stimmen und Sprachen erkennen, sondern auch noch verstehen, dass er ein Lied abspielen soll. Er muss also den Satz in einen Computerbefehl übersetzen. Auch hier funktioniert es dadurch, dass das Computerprogramm mit einer riesigen Anzahl Beispielsätze gefüttert wurde.

Und wie funktioniert Maschinelles Lernen denn nun genau?

Es gibt zwei verschiedene Verfahren. Das erste nennt man den
„symbolischen Ansatz“. Dabei geht es darum, Regeln zu erlernen. Zum Beispiel
wenn ein Mensch größer als 1,8m ist, dann ist er groß. Der zweite Ansatz heißt
einfach „nicht-symbolisch“. Hier ist das Gelernte indirekt gespeichert, so wie wir
auch einfach Fahrrad fahren können, ohne genaue Regeln zu befolgen. Das wäre ja
komisch, wenn wir die Regel hätten: „Linkes Bein strecken, wenn die linke
Pedale oben ist“.

Eine Möglichkeit des nicht-symbolischen maschinellen Lernens ist ein sogenanntes künstliches neuronales Netz. Dieses wurde unserem Gehirn nachempfunden, aber natürlich ganz stark vereinfacht. Es besteht aus Punkten, welche miteinander verbunden sind. Um einem neuronalen Netz etwas beizubringen, werden ihm ganz viele Beispiele gezeigt, so dass es lernt, wann es richtig und wann falsch liegt. Im Inneren des neuronalen Netzes wird dadurch die Stärke der Verbindungen geändert.

Ein einfaches neuronales Netz mit 3 Schichten und 11 Knoten. In der Praxis haben neuronale Netze hunderte von Schichten und tausende von KnotenGlossar: rnorm min Neuronales Netz Maschinelles Lernen

Was ist Keras?

Hej Leute,

vielleicht habt ihr schon mal von Keras im Zusammenhang mit
Neuronalen Netzen gehört. Nun fragt ihr euch, was das denn genau ist.

Ganz kurz: Keras ist
eine Schnittstelle zu mehreren Deep Learning Frameworks.

Aber das ist natürlich ein bisschen zu kurz. Also hier eine
etwas längere Erklärung.

Was ist ein Deep Learning Framework?

Ein Deep Learning Framework ist eine Programmbibliothek,
welche das Erstellen, Trainieren und Anwenden von Neuronalen Netzen relativ
komfortabel ermöglicht, ohne das Neuronale Netz komplett selber programmieren
zu müssen. In der Praxis wird nämlich nicht jedes Mal von Null begonnen,
sondern man möchte ja schnell zu Resultaten kommen und nicht das Rad nochmal
neu erfinden. Dafür gibt es mehrere Deep Learning Bibliotheken für verschiedene
Programmiersprachen.

Die bekanntesten sind (ohne Gewähr)

TensorFlow (Python, C/C++, Java, Go, JavaScript,
R, Julia, Swift)PyTorch (Python)Caffe (Python, Matlab, C++)Theano (Python)MXNet (C++, Python, Julia, Matlab, JavaScript, Go,
R, Scala, Perl)Microsoft Cognitive Toolkit / CNTK (Python, C++,
BrainScript)Keras (Python, R) Aber ist Keras dann so was wie TensorFlow?

Keras hat eine Sonderrolle, denn es ist eigentlich ein
Interface und setzt auf andere Frameworks auf. Damit können TensorFlow,
Microsoft Cognitive Toolkit und Theano als Backend verwendet werden, die
Befehle in Keras sind immer die gleichen. Keras wurde mit dem Ziel entwickelt, Experimente
schnell realisieren zu können. D.h. eine nutzerfreundliche API mit wenig
Overhead.

Kann ich Keras auch in R nutzen?

Ja, Keras ist neben MXNet eine der wenigen Bibliotheken,
welche auch für R vorhanden ist. Und da Keras als Backends ja TensorFlow,
Theano und Microsoft Cognitive Toolkit unterstützt, können wir diese also
ziemlich bequem aus R heraus steuern.

Der Befehl zum Installieren des Packages in R ist ziemlich
simpel, jedenfalls mit CPU-basiertem TensorFlow im Hintergrund.

install.packages("keras") <br>library(keras) <br>install_keras()

1

install.packages("keras") <br>library(keras) <br>install_keras()

Also, viel Spaß mit Keras!
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

Was ist Julia? Eine tolle Programmiersprache!

Julia ist eine junge Programmiersprache, die aktuell immer
mal wieder als tolle Alternative im Bereich Data Science genannt wird. Julia
wurde am MIT entwickelt, 2012 erschien die Open-Source-Version.

Julia ist eine General Purpose Language, wurde aber vor
allem für die Datenanalyse und das numerische Rechnen entwickelt. Julia benutzt
eine just-in-time compilation, welche zwischen einer klassischen
Compiler-Sprache (AOT = ahead of time) und einem Interpreter sitzt. Der Code
wird während der Ausführung kompiliert.

Der große Vorteil von Julia ist die Geschwindigkeit bei einem
dynamischen Typsystem, d.h. der Typ einer Variable (z.B. int) wird erst zu Laufzeit
überprüft. Andere Skriptsprachen, die ein dynamisches Typsystem haben, sind normalerweise
langsamer. Zudem kann R- und Python-Code mit den entsprechenden Bibliotheken
ausführen.

Die Geschwindigkeit von Julia ist bemerkenswert, da andere
Skriptsprachen schon über Jahre optimiert wurden. Dies kann durch die
Typ-Stabilität erklärt werden, so wirft z.B. 2^-5 einen Error, da 2 und -5
Integer sind, das Ergebnis aber nicht. R würde das Ergebnis einfach in eine
Kommazahl umwandeln. Die Typstabilität sorgt dafür, dass direkt der optimierte
C/FORTRAN-Code aufgerufen werden kann. Gleichzeitig sind die Funktionen
überladen, so dass es für viele Kombinationen von Typen im Hintergrund eine
eigene Funktion aufgerufen wird.

Es scheint so, dass Julia eine Konkurrenz für R oder Python im Bereich Data Science werden könnte. Zudem besteht ja die Möglichkeit, Code verschiedenster Programmiersprachen einzubinden.

Julia-Links

Die offizielle Website von Julia findest Du unter julialang.orgEine gute englische Einführung gibt es unter A Deep Introduction to Julia for Data Science and Scientif ComputingGlossar: rnorm min Neuronales Netz Maschinelles Lernen

GPU-Prozessoren für Künstliche Intelligenz

Hej Leute,

heute geht es um die Unterschiede zwischen CPU und GPU, denn
aktuell ist die Verwendung von GPUs für Maschinelles Lernen in aller Munde.
Aber was ist eigentlich eine GPU und warum sind die GPUs für Deep Learning so
gut geeignet?

Dazu klären wir erstmal, was eine CPU, eine GPU und auch
eine TPU sind. Danach ist klarer, warum die GPUs einen so großen Vorteil in der
KI haben.

Was ist der Unterschied zwischen CPU, GPU und TPU?

Die CPU ist der Hauptprozessor eines Rechners und für allgemeine
Aufgaben ausgelegt. Die GPU ist ein für 3D-Grafik optimierter Grafikprozessor.
Und die TPU ist ein Spezialprozessor von Google, der für Tensorflow optimiert
wurde.

Die CPU im Detail

CPU ist der Hauptprozessor eines Computers (CPU = central
processing unit = zentrale Verarbeitungseinheit). Die CPU besteht heutzutage
aus mehreren Prozessorkernen, die im Wesentlichen eigenständige CPUs sind.

Eine CPU setzt sich hauptsächlich aus einem Steuerwerk und
einem Rechenwerk zusammen. Daneben sind üblicherweise noch weitere Teile wie
zum Beispiel eine Gleitkomma-Recheneinheit vorhanden. Zudem ist die CPU über
einen Daten-Bus mit den anderen Komponenten des Rechners verbunden

Das Steuerwerk (engl. control unit) ist für die Befehlsverarbeitung
zuständig. Dazu holt es sich einen Befehl einen Befehl aus dem Speicher,
dekodiert ihn, führt ihn aus und schreibt das Ergebnis in den Speicher.

Das Rechenwerk besteht aus einer oder mehreren ALUs (arithmetic-logic
unit) und mehreren Registern. Die ALU kann zwei Binärwerte miteinander verrechnen.
Dabei sind mindestens die Basisbefehle ADD (Addition), NOT (Invertieren) und
AND (logische Und-Verknüpfung) vorhanden, meist aber noch weitere wie OR, XOR,
MUL, SUB, die aber auch durch die ersten drei abgebildet werden können.

Die GPU besticht durch Matrixberechnungen

Mit GPU bezeichnet man einen Grafikprozessor (graphical
processing unit), also einen Prozessor, der auf die Berechnung von Befehlen,
die für die Grafikdarstellung benötigt werden, optimiert ist. Eine oder mehrere
GPUs können in der CPU, onboard (auf der Hauptplatine), auf einer internen Grafikkarte
oder in externen Erweiterungsboxen (eGPU) sein.

Die GPU ist für 3D-Berechnungen ausgelegt. Typische Aufgaben
sind geometrische Berechnungen (Transformation, Rotation), Texture Mapping,
Shading oder Interpolations-Techniken. Dafür sind vor allem Matrix- und
Vektorberechnungen (Lineare Algebra) notwendig. Zudem sind GPUs hochgradig parallelisiert,
sie können also mehrere Datenblöcke gleichzeitig verarbeiten.

Die Kombination aus Parallelisierung und Matrix-Rechnung
machen GPUs so effektiv für moderne KI-Methoden wie Neuronale Netze. Dazu
weiter unten mehr.

Die TPU ist ein Spezialprozessor

TPU steht für Tensor Processing Unit und ist ein Prozessor,
der von Google speziell für die Berechnungen von Neuronalen Netzen entwickelt
wurde. Genauer gesagt für das Neuronale Netze-Framework Tensorflow. Im
Gegensatz zu GPUs sind die TPUs auf ein hohes Volumen von Berechnungen mit
niedriger Genauigkeit, z.B. 8-Bit. GPUs hingegen sind auf
32-/64-Bit-Operationen optimiert.

Warum brauchen wir GPUs in der KI?

Abstrakt gesehen brauchen wir die GPUs nicht, denn natürlich
kann auch das Rechenwerk einer CPU die entsprechenden Berechnungen ausführen.
Aber praktisch gesehen brauchen wir die GPUs aus Geschwindigkeitsgründen. Denn
die GPU ist optimiert auf Vektor- und Matrixberechnungen. Und die Architektur
der GPU ist auf parallele Verarbeitung ausgelegt. Beides sind Eigenschaften,
die für KI-Algorithmen, insbesondere für Neuronale Netze von enormer Bedeutung
sind.

Was haben Neuronale Netze mit Matrixrechnung zu tun?

Neuronale Netze basieren ganz Wesentlich auf Matrixberechnungen.
Zum Beispiel brauchen wir diese, um den Output eines Netzwerks schnell zu
berechnen. Achtung, jetzt wird es mathematisch:

bezeichnet das Gewicht der Verbindung vom k-ten Neurons der Schicht (l-1) zum j-ten Neuron in der Schicht l, den Bias des j-ten Neurons in der Schicht l, die Aktivierung des j-ten Neurons in der Schicht l die AktivierungsfunktionDann wird die Aktivierung der l-ten Schicht so berechnet

In Matrixschreibweise sieht das dann so aus:

Optimierung der Gewichte mittels Gradient Descent und Backpropagation

Um ein neuronales Netz zu trainieren, füttern wir es mit
einer Unzahl an Beispielen, so dass es die Gewichte der Verbindungen und den
Bias optimiert. Dafür wird meistens eine Variation des sogenannten Gradient
Descent-Algorithmus verwendet. Grob gesprochen geht es darum, dass die
Fehlerfunktion (loss function) möglichst klein. Es werden in jedem Schritt die
Gewichte also so angepasst, dass die Verbesserung der Fehlerfunktion maximal
wird. Dafür müssen wir wissen, wo die Funktion am steilsten bergab geht
(descent = Abstieg). Das wiederum hängt an der Ableitung (gradient), wissen die
Mathematiker.

Ein Spezialfall des Gradient Descent ist Backpropagation,
welches auf dem mittleren quadratischen Fehler basiert. Den mittleren
quadratischen Fehler kennen viele vermutlich schon von der linearen Regression.
Backpropagation ist kurz für „backward propagation of errors“ und das backward
kommt daher, dass das Neuronale Netzwerk rückwärts durchlaufen wird, also vom Output
Layer her.

Die genauen Formeln würden hier etwas zu weit führen, aber
im Wesentlichen sind es jede Menge Matrixmultiplikationen. Und dafür sind
wieder besonders geeignet: GPUs.

Parallelisierung in Neuronalen Netzen

Daten-Parallelisierung

Wir gruppieren die (Trainings-)Daten in sogenannte Mini-Batches. Ein Mini-Batch wird dann parallel in der GPU optimiert (gradient descent) und anschließend werden die Ergebnisse gemittelt.

Modell-Parallelisierung

Hier wird die Gewichtsmatrix in mehrere Untermatrizen
aufgeteilt, so dass diese dann parallel optimiert werden können. Haben wir zum
Beispiel eine Matrix mit 1000×1000 Einträgen, können wir diese in vier 1000×250
Matrizen splitten und diese dann an vier GPUs gleichzeitig zur Optimierung schicken.

Happy Coding, Euer Holger
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

Buchreview: Datenanalyse mit Python – McKinney

Das Buch „Datenanalyse mit
Python“ von Wes McKinney ist bei O’Reilly erschienen und kostet im Handel
44,90€. Die zweite Auflage, auf Deutsch erschienen im Oktober 2018, ist mit 522
Seiten ganz schön umfangreich, man bekommt also schon mal einige Seiten für
sein Geld. Die erste Auflage ist übrigens von 2012. Der Untertitel „Auswertung
von Daten mit Pandas, Numpy und IPython“ sagt eigentlich schon, dass es im
Wesentlichen um die Aufbereitung und Manipulation von strukturierten Daten
(Tabellen, Matrizen, Zeitreihen) – englisch data munging –  mittels Pandas und Numpy geht.
Datenvisualisierung mittels Matplotlib wird in einem Kapitel beschrieben.
ML-Algorithmen und statistische Auswertungen per scikit-learn und statsmodels
werden im vorletzten Kapitel angekratzt.

Über den Autor

Der Amerikaner Wes
McKinney hat Mathematik am MIT studiert und entwickelt seit 2007
Datenanalyse-Software, hauptsächlich für Python. So ist er der Hauptautor der Python-Bibliothek
pandas, um die kein Data Scientist
herumkommt. Zudem ist er in Apache Arrow
involviert, einer Plattform für In-Memory-Daten, welche mehrere Programmiersprachen
unterstützt. In 2018 hat McKinney Ursa Labs
zusammen mit Hadley Wickham, den jeder R-Programmierer kennt, gegründet. Ursa
Labs ist eine Non-Profit-Organisation, die sich open-source, cross-language
Software für Data Science auf die Fahne geschrieben haben.

Die deutsche Übersetzung wurde von Christian Tismer,
Kristian Rother und Kathrin Lichtenberg angefertigt.

Inhaltsverzeichnis

EinleitungGrundlagen von Python, IPython und
Jupyter-NotebooksIn Python integrierte Datenstrukturen,
Funktionen und DateienGrundlagen von NumPy: Arrays und vektorisierte
BerechnungErste Schritte mit pandasLaden und Speichern von Daten sowie DateiformateDaten bereinigen und vorbereitenDatenaufbereitung: Verknüpfung, Kombinieren und
UmformenPlotten und VisualisierenAggregation von Daten und GruppenoperationenZeitreihenPandas für FortgeschrittenenEinführung in Modellierungsbibliotheken in
PythonBeispiele aus der DatenanalyseAnhang A: NumPy für Fortgeschrittene

Anhang B: Mehr zum IPython-System

Für wen ist „Datenanalyse mit Python“ geeignet?

Prinzipiell ist das Buch für jeden Python-Programmierer
geeignet, der sich mit Datenaufbereitung und –manipulation herumschlagen muss.
Das sind vermutlich weniger die reinen Software-Entwickler, sondern eher die
Data Engineers und Data Scientists, die zwar meistens noch tiefergehende
Analysen machen, aber das sogenannte Data Munging nimmt eben einen großen Teil
der Arbeit in Anspruch. Da schadet es nichts, sich damit auszukennen, um
effizient und schnell zu programmieren.

Die ersten Kapitel sind sehr elementar und richten sich an
diejenigen, die noch nie mit Python, numpy und pandas zu tun hatten. Aber es
ist ja ein dickes Buch. Es macht also nichts, wenn man die ersten 100 Seiten
überspringen kann. Los geht es also eigentlich in Kapitel 4, in dem die
Grundlagen von Numpy behandelt werden.

Fazit

Wer Daten mit Python analysieren will, kommt um die
Bibliotheken numpy und pandas nicht herum und das ist genau der Schwerpunkt
dieses Buchs. Es beschreibt die Datenstrukturen und Funktionsweisen mit
präziser Sprache. Das macht es zwar nicht gerade zu einem einfach zu lesendem
Buch, dafür hat es die benötigte Genauigkeit, die man als Programmierer
benötigt.

An der ein oder anderen Stelle hätte ich mir praxisnähere
Beispiele gewünscht. Hier wurde auf Kürze und Konzentration auf das Wesentliche
mehr Wert gelegt. In Kapitel 14 kommen dann aber doch noch einige spannende
Beispiele aus der Praxis.

Insgesamt kann ich dieses Buch allen angehenden Data Scientisten, die Python lernen wollen, empfehlen. Es ist nicht mal eben am Wochenende durchgearbeitet, enthält dafür umfangreiches Wissen zu numpy und pandas. So eignet es sich auch später noch als Nachschlagewerk.

Auf der Website von O’Reilly gibt es eine Leseprobe, das gesamte Kapitel 4

Glossar: rnorm min Neuronales Netz Maschinelles Lernen

Eine neue Art im Neuronale Netze-Zoo?

Spektrum titelt recht reißerisch: „Eine neue Form von KI?„, immerhin mit Fragezeichen. Worum geht es denn überhaupt. Das Paper „Neuronal Ordinary Differential Equations“ wurde auf im Rahmen der NeurIPS 2018 mit dem Best Paper Award ausgezeichnet.

Was sind ODE-Netze?

Die Idee, die in dem Paper beschrieben wird, hört sich interessant an. Diese wurde übrigens schon 2017 von anderen Autoren veröffentlicht. Grundsätzlich besteht ein Neuronales Netz ja aus einer Eingangsschicht, mehrerer versteckter Schichten (hidden layers) und einer Ausgangsschicht. Um diese sogenannten hidden layers geht es. Anstatt diese als diskrete Schichten zu betrachten, benutzen die Wissenschaftler ein kontinuierliches Modell, indem sie Ableitung des hidden states parametrisieren. Das wird mittels eines Differentialgleichungen-Solver (ODE = ordinary differential equations) gelöst. Im Endeffekt ist das Konstrukt kein Neuronales Netz mehr, denn die ganzen Knoten und Verbindungen sind ja nicht mehr da, sondern sind durch ein „Feld“ ersetzt.

Noch ist die Entwicklung in einem frühen Stadium. Das Paper gibt einen proof of concept, mehr aber noch nicht. Wie nützlich das Konstrukt ist, wird sich herausstellen. Aber super spannend, denn jetzt kommen Analysis-Methoden zum Einsatz und auf diesem Gebiet kennen sich die Mathematiker sehr gut aus.

Links

Das Paper „Neuronal Ordinary Differential Equations“ ist auf arxiv.org zu finden. Hier ist der Link dazu. Nicht zu vergessen das erste Paper zu Neuronalen ODEs von 2017: Reversible Architectures for Arbitrarily Deep Residual Neural Networks

Der zugehörige Artikel auf Spektrum.de findet Ihr hier.

Und hier ist noch ein besserer Artikel dazu auf MIT Technological Review
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

Maschinelles Lernen und die französische Revolution

Letztes Jahr wurde ein Paper in „Proceedings of the National Academy of Sciences of the United States of America“ (PNAS) veröffentlicht, welches die Rhetorik der ersten Jahre der französischen Revolution untersucht. Das interessante daran aus Data Science Sicht ist die Nutzung von ML-Algorithmen, um eine große Menge an Reden (40.000) zu analysieren. Soweit ich weiß, ist das eine der ersten Forschungen, welche Maschinelles Lernen verwendet, um historische Daten dieser Größenordnung auszuwerten. Besonders toll finde ich, dass die NLP-Methoden (NLP = Natural Language Processing) eine praktische Anwendung finden.

Ich bin gespannt, ob durch die fortschreitende Digitalisierung und Veröffentlichung historischer Daten die quantitativen Analysen in den Geisteswissenschaften zunehmen. Wie jeder, der mit Datensätzen zu tun hat, sind aber ebenso wichtig wie neue Methoden die richtigen Fragestellen. Daher ist die Zusammenarbeit zwischen Fachexperten (Domain Owner) und Data Scientisten so wertvoll.

Vorgehen

Nach der typischen Aufbereitung, sprich Stop-Word-Removal, wurden die Reden mittels Latent Dirichlet Allocation (LDA) in 100 „Themen“ einsortiert. Das passiert anhand von gemeinsam auftauchenden Wortpaaren. Die Themen wurden dann im zeitlichen Verlauf analysiert und dabei Kennzahlen für Novelty (Abweichung von vorherigen Reden), Transience (Abweichung von folgenden Reden) und Resonance (die Differenz der beiden) quantifiziert.

Links

Hier geht es zu einem Überblicks-Artikel über das Paper des Santa Fe Institute. Das Paper „Individuals, institutions, and innovation in the debates of the French Revolution„ selbst ist bei PNAS zu finden.
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

Buchtipp: Bayesian Methods for Hackers

Das kostenlose Ebook „Bayesian Methods for Hackers“ von Cameron Davidson-Pilon erklärt die Bayeschen Algorithmen in Python mittels der Python-Library PyMC. Dabei richtet sich das Buch an „Hacker“. Damit ist gemeint, dass es in erster Linie um die praktische Umsetzung und nicht um die mathematischen Grundlagen geht. Nichtsdestotrotz wird einiges an Mathematik verlangt, das liegt aber in der Natur der Sache.

Bei der Veröffentlichung geht Davidson-Pilon dankenswerterweise den Open-Source-Weg, d.h. das gesamte Buch ist als Jupyter Notebooks aufgebaut, welche auf Github zur Verfügung stehen. Eine gedruckte Version gibt es auch auf Amazon zu kaufen. Zudem gibt es eine Adaption an Tensorflow Probability, wenn man die Tensorflow-Umgebung und TPU/GPUs nutzen will.

Inhalt

Das Buch ist in 7 Kapitel unterteilt, welche jeweils als Jupyter Notebook (ipynp-Datei) zur Verfügung stehen. Am besten klont ihr euch das gesamte Github-Repository und öffnet es mit Jupyter Notebook oder einem anderen Editor, der Notebooks anzeigen kann. So könnt ihr lesen und die Beispiele ausführen und modifizieren. Alternativ könnt ihr euch die Notebooks auch im Browser mit dem nbviewer ansehen. Die einzelnen Kapitel habe ich verlinkt.

Introduction to Bayesian MethodsA little more on PyMCOpening the black box of MCMCThe greatest theorem never toldWould you rather lose an arm or a legGetting our prior-ities rightBayesian Machine Learning (in Arbeit)Das Buch als gedruckte Version

Das Buch gibt es auch in einer gedruckten Version vom Addison-Wesley Verlag (2015). Durch Klick auf das Bild gelangt Ihr zu Amazon.

Hier ist der Link zur Website des Buches und hier der Link zur zugehörigen Github-Seite.

Viel Spaß beim Lesen.
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

82.000 freie IT-Jobs. Fachkräftemangel?

Laut Bitcom spitzt sich der IT-Fachkräftemangel zu. In ihrem Pressebericht gibt es einige interessante Details zur Lage der IT-Experten am Arbeitsmarkt.

Aber die Kernaussage: Fachkräftemangel? Richtig ist, dass sich die Zahl der offenen Stellen im Jahr 2018 deutlich erhöht hat. Gleichzeitig wird aber gesagt, dass die Besetzung der Stellen vor allem am Geld scheitert. 76% der Unternehmen beklagt, dass die Bewerber zu hohe Gehaltsvorstellungen haben.

Schaut Euch den Bitcom-Report mal an.
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

KI-Support für Schlaganfallpatienten

In dem Artikel „Dr. Data soll Ärzte unterstützen“ auf n-tv.de geht es um eine Studie des Neurochirurgs Dietmar Frey an der Berliner Charité. In dieser Studie geht es um die akute Schlaganfallbehandlung, bei der wenig Zeit für Diagnostik und Therapieentscheidung bleibt. Hier sollen Daten helfen, indem der Algorithmus aus einer Datenbank von Schlaganfallpatienten die zum aktuellen Patienten ähnlichen findet. So bekommt der Arzt Anhaltspunkte für seine Entscheidung. Dabei sollen Verfahren des maschinellen Lernens zum Einsatz kommen.

Das Themenfeld „KI in der Medizin“ ist total spannend und wir werden wohl viele Neuigkeiten über Fortschritte sehen. Man darf aber nicht vergessen, wie komplex das Thema ist. So ist in der Medizin das Abwägen zwischen Risiko und Nutzen besonders heikel. Daneben muss man sich auch mit Datenschutz und zu recht strengen Medizinprodukt-Vorschriften auseinandersetzen.

Ich denke, der Artikel beschreibt kurz und knackig den aktuellen Stand zu „KI und Medizin“ in Deutschland. Es geht aktuell darum, anhand von Datenbanken vergleichbare Fälle herauszusuchen und damit die behandelnde Ärztin zu unterstützen. Das ist schon eine komplexe Angelegenheit, kratzt auf der anderen Seite das maschinelle Lernen nur an der Oberfläche.

Den gesamten Artikel findet Ihr hier bei n-tv.
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

Internetseite Data Science Jobs in Deutschland

Auf der Seite datasciencejobs.de werden aktuell einige Stellenangebote rund um das Thema Data Science und Maschinelles Lernen gesammelt. Dabei werden einfach die Jobs als „Blogbeiträge“ aufgelistet. Auf der Detailseite ist dann die Stellenbeschreibung mit Anforderungsprofil und einem Link zur Firma zu sehen.

Der erste Eintag der Seite ist von November 2017, es ist also noch eine relativ neue Seite. Leider gibt es keine Suchfunktion. Auch Filter sind nicht vorhanden, lediglich nach vorgegebenen Tags kann man filtern. Auch fehlt mir, von wann die Stellenausschreibung ist. Dafür gibt es einen RSS-Feed, mit dem Ihr die neuesten Beiträge bequem abonieren könnt.

Insgesamt scheinen die großen allgemeinen Job-Plattformen mit ihren umfangreichen Such- und Filterfunktionen für die Jobsuche im Data-Science-Umfeld allerdings besser geeignet zu sein.

Aber macht Euch selber ein Bild. Hier geht es zu datasciencejobs.de
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

5 Alltags-Beispiele für KI

Der leicht verständliche, kurzer Artikel „Wie Künstliche Intelligenz unser Leben berührt“ auf orange by Handelsblatt beschreibt 5 Alltags-Beispiele, in denen künstliche Intelligenz schon heute eingesetzt wird.

Und das sind laut Artikel:

Gesichtserkennung auf Smartphone und PCFacebook-NewsfeedChatbots, insbesondere SprachassistentenEinparkhilfe im AutoDiagnose von KrankheitenJetzt können wir natürlich diskutieren, ob das schon künstliche Intelligenz ist, also ob wirklich Intelligenz dahinter steckt. Und vermutlich sind das eher Beispiele für Maschinelles Lernen, mit dem Trendwort KI versehen. Aber eigentlich geht es ja darum, dass immer mehr komplexe Tätigkeiten von Maschinen erledigt bzw. unterstützt werden.

Hier geht es zum gesamten Artikel …
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

20 einflußreiche Deep Learning Paper 2018

In dem Artikel „Most Influential Data Science Research Papers for 2018“ listet Daniel Gutierrez 20 wissenschaftliche Paper zum Themengebiet Deep Learning / neuronale Netze mit jeweils einer kurzen Beschreibung auf. Die Paper liegen alle auf arxiv.org, sind also für jeden frei zugänglich.

Die ersten Paper der Liste sind Überblicksartikel, die gut geeignet sind, sich auf den aktuellen Stand der Forschung bezüglich Neuronaler Netze zu bringen. So zeigt der Artikel On the Origin of Deep Learning die historische Entwicklung der Neuronalen Netze auf.

Besonders interessant für mich als Mathematiker ist der Artikel Deep Learning: An Introduction for Applied Mathematicians, der die Deep Learning zugrundeliegenden Ideen mathematisch erklärt.

Hier findet Ihr die gesamte Liste mit den Papern.

Viel Spaß beim Lesen.
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

Install Anaconda – Die Python-Distribution Anaconda

Hej Leute,

ihr wollt als Data Scientist durchstarten, habt euch
vorgenommen, Python zu lernen und wollt nun wissen, wie ihr anfangt. Zuerst
braucht ihr mal eine Python-Distribution, also eine Software, welche Python und
gegebenenfalls noch mehr enhält. Statt einfach nur auf python.org zu gehen und
sich die aktuellste Version für Euer Betriebssystem, also zum Beispiel Python
3.7.1 für Windows, herunterzuladen, empfehle ich Euch die Python-Distribution
Anaconda. Diese enthält nämlich noch einiges Nützliches mehr.

In meine Anleitung
zur Installation von Python findet ihr einen kurzen Abriss über verschieden
Python IDEs und Anaconda, aber alles ziemlich knapp. Hier geht es aber weiter
mit den Tiefen von Anaconda. Natürlich bleiben wir trotzdem an der Oberfläche,
schließlich wollt Ihr kein ganzes Buch über Anaconda lesen.

Was ist Anaconda?

Anaconda ist eine Python-Distribution für Windows, Linux und
MacOS, welche aus IPython, Spyder, Jupyter Notebook und nicht zu vergessen
conda besteht.

IPython:
eine Python-KommandozeileSpyder:
ein Editor für Python-Skripte mit vielen Tools, welche ich hier erkläreJupyter
Notebook: ein browserbasierter Editor für spezielle Skripte (die
sogenannten Notebooks), welche neben dem Code auch formatierten Text und
Grafiken enthaltenConda:
ein Package-Management-System, d.h. mit conda lassen sich Abhängigkeiten
zwischen Package-Versionen gut verwalten und die Packages updatenWenn ihr also noch kein Python installiert habt, dann ist
Anaconda auf jeden Fall das richtige für Euch. Einfach zu installieren und
upzudaten. Auf der Website von Anaconda
gibt es einfach einen Installer, also auf den Download-Bereich gehen,
herunterladen, installieren, Fertig.

IPython

IPython steht für Interactive Python und ist eine interaktive
Python-Shell, welche eng mit Jupyter Notebook verbunden ist. In früheren
Versionen war es eine Einheit, die man dann aber getrennt hat. Deshalb ist es
etwas schwierig, im Netz Informationen nur zu IPython zu bekommen.
Grundsätzlich braucht ihr euch um IPython gar nicht so sehr zu kümmern, denn
unsere Python-Skripte schreiben wir mit Spyder oder in Jupyter Notebook, welche
beide mit IPython kommunizieren. IPython ist sozusagen die zugrundelegende
Python shell, welche einfach mehr Funktionalität bietet als das Standard
Python-Prompt, insbesondere ermöglicht es die grafische Ausgabe. In der offiziellen
Dokumentation findet ihr eine Liste mit Features.

Anacondas IDE Spyder

Spyder ist eine Python IDE und wird bei Anaconda
mitgeliefert, also quasi die offizielle Anaconda IDE, wenn aktuell auch nicht
mehr von Anaconda bezahlt. Aber erstmal ganz langsam: Was ist nun eine IDE und
wofür brauche ich diese? IDE steht für integrated development environment, also
eine integrierte
Entwicklungsumgebung. Diese ist eine Sammlung von Tools, welche uns die
Software-Entwicklung erleichtern. Meistens sind die IDEs auf eine
bestimmte  Programmiersprache
zugeschnitten. Unter Windows ist die bekannteste Visual Studios,  für Mac ist es XCode, aber es gibt
haufenweise IDEs, jede mit ihren Vor- und Nachteilen. Eclipse, ursprünglich für
Java entwickelt und bei Java-Programmierern beliebt, unterstützt auch C++, PHP
und es gibt Plugins, mit denen unter anderem Python oder R angebunden werden.

Spyder besteht aus mehreren Fenstern, die natürlich alle
angepasst werden können. So sind neben dem Skript noch ein Variablen-Explorer
und die Ipython-Konsole zu sehen. Wenn man ein Skript entwickelt, schickt man
die Befehle per Shortcut an die Konsole. Zudem gibt es gute Debugging und
Profiling-Möglichkeiten. Zusätzlich erlaubt ein Plugin für Spyder auch das
Erstellen und Bearbeiten von Jupyter Notebooks. Alles in allem also ein super
Tool, um sofort mit Python loszulegen.

Jupyter Notebook

Jupyter Notebook ist eine Weboberfläche (also per Webbrowser
wie Chrome zu bedienen), welche neben dem Programmcode in mehrere
Programmiersprachen (in unserem Fall Python oder R) auch formatierten Text und
Grafiken. Notebooks sind ein sehr guter Einstieg in die Python-Programmierung
und es gibt viele Tutorials im Notebook-Format, unter anderem bei Kaggle oder in
diesem Guthub-Repository
findet ihr eine Reihe von interessanten Jupyter Notebooks.

Conda

Conda ist ein Package-Management System, welches die
verschiedenen Versionen von Python und den Libraries verwaltet und dafür sorgt,
dass alles stabil läuft. Super nützlich, insbesondere wenn Projekte nicht mehr
reines Hobby sind (und auch dann ist es hilfreich). Zuerst allerdings nicht
ganz einfach zu verstehen, aber im nächsten Kapitel erkläre ich die Grundlagen
von conda.

Anaconda richtig benutzen

Was sind Conda Environments?

In Anaconda besteht die Möglichkeit, mehrere Umgebungen zu
definieren. Diese Umgebungen können unterschiedliche Versionen von Python und
Packages installiert haben. Das macht Sinn, wenn man sauber verschiedene
Projekte trennen will, also zum Beispiel eine Umgebung für Tensor-Flow und eine
andere für PyTorch. Oder ihr wollt testen, ob alles auf dem Produktiv-Server funktionieren
wird, auf dem ihr nicht mal eben ein Update machen könnt.

Um ein Environment zu erzeugen, gebt ihr im Anaconda Prompt
folgendes ein

conda create –name EnvName

Wollt ihr eine andere Python-Version benutzen, geht das
folgendermaßen

conda create -n EnvName python=3.4

1

conda create -n EnvName python=3.4

Und wenn ihr nun noch bestimmte Package-Version benutzen
wollt, könnt ihr diese einfach aufzählen

conda create -n myenv python=3.4 scipy=0.15.0 astroid babel

1

conda create -n myenv python=3.4 scipy=0.15.0 astroid babel

Man kann auch eine Datei schreiben, in der das alles
definiert ist. Aber dazu ein anderes Mal mehr.

Um nun das neue Environment zu nutzen, müsst ihr es
aktivieren. Unter Windows macht ihr das mit activate EnvName, unter
Linux und MacOS mit source activate EnvName. Damit sollte sich die Kommandozeile
geändert haben.

Das Deaktivieren geht einfach über deactivate bzw. source
deactivate

Wollt ihr Spyder oder Jupyter Notebook in einem Environment nutzen,
müsst ihr es zuerst dort installeren. Das geht über conda install -n myenv spyder. Danach dann einfach
das Environment aktivieren und dann spyder oder eben jupyter
notebook eintippen.

Der Anaconda Navigator

Wenn ihr Anaconda installiert, wird auch der Navigator
mitgeliefert. Dieser ist quasi die bequeme Version vom Anaconda Prompt, d.h.
ihr könnt per Mausklick ein neues Environment erzeugen und Packages updaten.

Anaconda updaten

Um immer die neuste Versionen von Python, IPython, Spyder
und all den Packages zu haben, gibt es zwei Befehle, die ihr kennen solltet
bzw. einfach diese Seite bookmarken und dann immer wieder hier rauskopieren.
Zum Updaten öffnet ihr die Anaconda-Prompt und gebt dann zweimal die folgenden
Befehle ein. Der erste Befehl  updated
das conda-Programm

conda update conda

Im Anschluss updated ihr das Anaconda-System

conda update
anaconda

Nach einer kurzen Warterei wird eine Liste mit allen
anstehenden Veränderungen (Upgrades und Downgrades) angezeigt, die ihr noch
bestätigen müsst. Ja, es gibt je nach installierten Versionen der Packages auch
Downgrades. Conda versucht, eine möglichst stabile Umgebung zu erzeugen. Wenn
also ein Packages auf einer älteren Version eines anderen Packages aufbaut,
wird conda den Konflikt auflösen.

Wie gesagt, am besten zwei Mal hintereinander ausführen,
damit auch alle Abhängigkeiten sauber aufgelöst werden. Danach solltet ihr eine
Anaconda-Version haben, wie als hättet ihr sie frisch heruntergeladen und
installiert.

Das solltet ihr unbedingt im Root-Environment machen

Warum ihr nicht conda update –all aufrufen solltet, oder doch?

Wenn ihr ein bisschen im Netz sucht, werdet ihr auch auf den
Befehl

conda update –all

stoßen. Der macht ein bisschen was anderes. Damit
installiert ihr zu jedem Package die neueste Version (unter der Veraussetzung,
dass alle Abhängigkeiten erfüllt sind). Das bringt jedes Package auf den
neusten Stand, denn ein Anaconda-Release kann auch mal einige Monate alt sein. Früher
führte das nicht unbedingt zu einer stabilen Umgebung. Anaconda hat in ihren
Distributionen extra die Package-Versionen so ausgewählt, dass alles gut
zusammenspielt.

Ihr müsst euch also entscheiden, ob ihr eine möglichst
stabile oder eine möglichst aktuelle Umgebung haben wollt.

Pip-Packages und manuelle Installation

Noch ein Wort der Warnung zu mit pip oder manuell per python setup.py install installierten Packages.
Diese werden von conda nicht berücksichtigt, denn woher soll conda wissen, was
ihr da installiert habt. Hier müsst ihr euch selber um das Update kümmern.
Prinzipiell sollte man also immer per conda installieren, sofern es diese Option
gibt.
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

Python-Beispiel: Wochentage

Hej Leute,
Python-Bite steht für kleine Beispiel Python-Codehappen, die ein Befehl oder die Anwendung einer Library verdeutlichen. Heute geht es darum, wie Ihr den Wochentag eines Datums herausfindet.
Dafür gehen wir in mehreren Schritten vor. Als ersten setzen wir die lokalen Einstellungen auf deutsch, ansonsten bekommen wir nämlich die englischen Wochentage. Das geht mit dem Befehl

Python

locale.setlocale(locale.LC_ALL, 'deu_deu')

1

locale.setlocale(locale.LC_ALL, 'deu_deu')

Dann sagen wir dem Benutzer, dass er sein Geburtstag eingeben soll. Die Eingabe ist natürlich erstmal ein String, den wir in den Datumstyp umwandeln wollen. Hier bietet es sich an, eine Überprüfung zu machen, ob die Eingabe im richtigen Format ist, der Einfachheit halber lasse ich es aber weg.
Im nächten Schritt wollen wir den eingebenen String in ein Datum umwandeln. Hierzu nutzen wir die Library datetime, denn mit dem folgenden Befehl können wir das erreichen.

Python

datetime.datetime.strptime(birthdate,'%d.%m.%Y').date()

1

datetime.datetime.strptime(birthdate,'%d.%m.%Y').date()

So, nun haben wir also ein Datum und der Typ date liefert auch schon die passende Funktion weekday mit, d.h. mit birthday.weekday() bekommen wir den Wochentag geliefert. Allerdings nur als Zahl, welche wir noch in den Wochentag-Namen umwandeln wollen. Dafür ist die Library „calendar“ geeignet. denn diese enthält das Array day_name. Wir suchen also aus dem Array einfach das Element an der Stelle der Wochentagszahl raus. Und das geht so:

Python

calendar.day_name[birthday.weekday()]

1

calendar.day_name[birthday.weekday()]

 
Hier also nochmal der ganze Code zum direkt ausprobieren.

Python

# -*- coding: utf-8 -*-
"""
Wochentag des Geburtstags

@author: Holger
"""

import datetime
import calendar
import locale

locale.setlocale(locale.LC_ALL, 'deu_deu')

print('Hallo, wie heißt Du?')
name = input()
print('Hallo '+name)
print('Bitte nenne mir Dein Geburtstag (TT.MM.JJJJ):')
birthdate = input()

#in Datumformat konvertieren
birthday = datetime.datetime.strptime(birthdate,'%d.%m.%Y').date()

print('Du bist an einem '+calendar.day_name[birthday.weekday()]+' geboren.')

1234567891011121314151617181920212223

# -*- coding: utf-8 -*-"""Wochentag des Geburtstags @author: Holger""" import datetimeimport calendarimport locale locale.setlocale(locale.LC_ALL, 'deu_deu') print('Hallo, wie heißt Du?')name = input()print('Hallo '+name)print('Bitte nenne mir Dein Geburtstag (TT.MM.JJJJ):')birthdate = input() #in Datumformat konvertierenbirthday = datetime.datetime.strptime(birthdate,'%d.%m.%Y').date() print('Du bist an einem '+calendar.day_name[birthday.weekday()]+' geboren.')

Und jetzt experimentiert ein bisschen selber herum. Kommentiert mal die Zeile mit locale aus, etc.
Happy Coding,
Euer Holger
Glossar: rnorm min Neuronales Netz Maschinelles Lernen

Meine 15 nützlichsten RStudio Shortcuts

Hej Leute,
Ihr wollt Profi-RStudio-Nutzer werden? Oder einfach nur schneller in R programmieren? Wie wir das aus anderen Programmen kennen, sind Shortcuts dafür eine Voraussetzung. Jetzt ist es natürlich in R Studio nicht so essentiell wie in Excel, da es ja nicht größtenteils um das Eintippen von Code geht und nicht, die richtigen Buttons anzuklicken, aber dennoch kann man mit den Tastaturkürzeln deutlich effizienter die R Studio Oberfläche nutzen. Daher habe ich für Euch meine 15 wichtigsten RStudio-Shortcuts aufgeschrieben.
 
1. Strg + Eingabetaste
Das wichtigste Tastenkürzel überhaupt, das vermutlich jeder von Euch kennt. Denn ohne kann man sich die Verwendung von RStudio nicht vorstellen. Mit Strg + Eingabetaste wird der markierte Skript-Teil oder die aktuelle Zeile an die R-Konsole geschickt und damit ausgeführt. Für die Schnellen unter Euch ist der zweite Teil wichtig, denn ich muss gar keinen Code markieren, sondern nur den Cursor an der richtigen Position haben. Um noch eine Schippe Geschwindigkeit draufzulegen, braucht Ihr natürlich noch die Shortcuts für das schnelle Markieren von Codeabschnitten. Und da kommt schon der nächste Shortcut ins Spiel.
2. Alt + Pfeil links/rechts
Damit Ihr schnell im Skript navigieren könnt, braucht Ihr dafür natürlich einen Shortcut. Nach oben und unten ist klar, das geht wie üblich mit den Bild hoch/runter Tasten. Aber um an den Anfang oder das Ende einer Zeile zu springen, und nicht einfach nur auf die Pfeiltasten zu drücken und zu warten, nehmt Ihr einfach die Alt-Taste dazu. Denn mit Alt + Pfeil links/rechts springt der Cursor an den Anfang bzw. Ende einer Zeile. Aber Achtung: Alt + Pfeil hoch/runter schiebt die aktuelle Zeile im Skript nach oben bzw. unten, also nicht aus Versehen diese Tasten drücken. Mit diesem RStudio Shortcut wird das Auswählen von mehreren Zeilen Code schneller, denn wenn der Cursor erstmal am Anfang einer Zeile ist, können dann mit Shift + Pfeil hoch/runter ja dann fix die entsprechenden Zeilen ausgewählt werden.
3. Tab
Autovervollständigung – das Feature schlechthin. Eigentlich hätte ich diesen R Shortcut auf Platz 1 setzen sollen. Denn habt Ihr einen R-Befehl angefangen zu tippen, schlägt Euch RStudio mögliche Vervollständigungen vor. Und dafür müsst Ihr nichts tun, außer vielleicht eine Millisekunde warten. So tippe ich nur agg und drücke dann die Tab-Taste, sobald das Auswahlmenü aufgepoppt ist und schon steht „aggregate(„ da und ich kann die Parameter einsetzen. In dem Auswahlmenü navigiert Ihr übrigens einfach mit Pfeil hoch/runter, kein Grund, die Maus zu benutzen.
4. Alt + –
Wir sind ja alles ordentliche Programmierer und benutzen für die Zuordnung den Pfeil <- und nicht das Gleichheitszeichen, oder? Ok, ertappt. Aber tatsächlich läßt sich der Zuordnungspfeil super schnell erstellen, nämlich mit dem RStudi Tastaturkürzel Alt + – (Minus). Super simpel und in fast jeder R-Code-Zeile zu verwenden.
 
5. Strg + F
Der Klassiker, den Ihr hoffentlich auch schon aus anderen Programmen wie Word oder Excel kennt. Mit Strg + F öffnet sich oberhalb des Skripts die Suchmaske, mit der Ihr ein Wort im Skript finden und auch ersetzen könnt. Interessanterweise funktioniert das Kürzel Strg + H, welches in vielen Programmen den Suchen und Ersetzen-Dialog aufruft, in RStudio nicht. Aber da Suche und Suche und Ersetzen sowieso in der Suchmaske nebeneinander stehen, ist das auch gar nicht nötig. Hier noch ein Power-Tipp zum Ersetzen: Markiert vorher das Wort, welches Ihr ersetzen wollt und benutzt dann den Shortcut Strg+F, dann wird nämlich dieses Wort direkt schon in Find eingetragen.
 
6. F1
Ok, Ihr wisst, wie ein Befehl heißt, aber braucht Details dazu. Schaut in mein R-Glossar – R-Befehle mit knackiger Erklärung und guten Beispielen – oder schreibt ?Befehlsname oder drückt einfach F1, wenn der Cursor auf der Funktion steht.
 
7. Strg + L
Ist die R-Konsole voll von den vorherigen Aufrufen? Dann drückt Strg + L und löscht damit die bisherige Ausgabe aus der Konsole
 
8. Strg + 1, Strg + 2
Ehrlich gesagt braucht man diese Shortcuts gar nicht so häufig, denn das meiste spielt sich doch im Skript ab. Aber wenn ihr schnell mal in die R-Konsole springen wollt, benutzt Strg + 2, um mal eben ein paar Befehle auszuprobieren. Dann mit Strg+2 zurück zum Skript, um mit der eigentlichen Arbeit fortzufahren.
 
9. Strg + Shift + R
Dieser R-Shortcut ist super nützlich. Ihr könnt Eure R-Skripte strukturieren, indem Ihr Abschnitte einfügt. Diese lassen sich dann mit dem folgenden Shortcut ein- bzw. ausblenden. Sobald Euer Code eine gewisse Länge hat, ist das definitiv zu empfehlen. Und es ist auch echt schnell gemacht, einfach Strg + Shift + R drücken, benennen und fertig.
 
10. Alt + L, Alt + Shift + L
Sind mehrere Zeilen markiert oder noch besser ein Abschnitts-Label gesetzt (siehe letzten Shortcut), kann dieser mit Alt+L eingeklappt und mit Alt + Shift+L wieder ausgeklappt werden. So behaltet Ihr und die Leute, die Euren Code blicken müssen, den Überblick.
 
11. Strg + Shift + M
Finger verknotet beim Erzeugt die Pipe %>%, dann schafft das RStudio Tastenkürzel Strg + Shift + M Abhilfe. Auf deutschen Tastaturen ist die Pipe ansonsten wirklich schlecht tippbar, aber so nützlich, wenn Ihr das tidyverse nutzt.
12. Strg + +. Strg + –
Mit diesem Shortcut skaliert Ihr die Größe der Schrift. Ok, zugegeben, ist ein Spezialfall, aber ziemlich praktisch, wenn man zwischen Laptop und Docking-Station mit Monitoren hin und herwechselt. So hat mein Laptop eine ziemlich hohe Auflösung, also muss ich die Schrift ein bisschen vergrößern. Die Monitore sind aber groß genug bzw. haben für die Größe nur Full-HD, also dort ist es besser, die Schrift zu verkleinern.
 
13. Strg + Shift + a
Ihr wollt sauber formatierten Code, habt aber keine Lust, das alles selber zu machen. Markiert den Bereich, den ihr formatieren wollt und drückt Strg + Shift + A und schon ist alles sauber formatiert, wie es sein sollte.
 
14. Strg + Shift + C
Anstatt an den Anfang der Zeile zu gehen (siehe Shortcut Nr. 2) und dann die Raute zu setzen, um die Zeile auszukommentieren, könnt ihr auch einfach Strg+Shift + C drücken und schon ist die Zeile auskommentiert. Und das Ganze unabhängig von der Cursor-Position, was wirklich praktisch ist.
 
15. Strg + F11, Strg + F12
Last but not least ein nützlicher Shortcut, um zwischen mehreren geöffneten Skripten hinu nd her zu springen.Mit Strg + F11 geht ihr zum vorherigen Skript bzw. Tab, der gerade offen ist, mit Strg + F12 zum nächsten Skript bzw. Tab. Damit navigiert ihr schnell zwischen verschiedenen offenen R-Skripten oder zwischen Skript und RMarkdown oder was ihr sonst noch so in RStudio treibt.
 
 
Das waren meine 15 wichtigsten RStudio Shortcuts. Auch wenn ihr schon RStudio-Profis seid, hoffe ich, dass das ein oder andere RStudio-Tastenkürzel noch nicht bekannt war, so dass Ihr Euren Workflow verbessern könnt.
Also, happy RStudioing,
Euer Holger
Glossar: rnorm min Neuronales Netz Maschinelles Lernen RStudio

Die Statistik-Software R

R ist eine Programmiersprache, die vor allem für statistische Auswertungen und Datenanalysen benutzt wird. Dabei wächst die Anzahl der Benutzer stetig, insbesondere durch die aktuellen Data Science Trends wie Maschinelles Lernen. Mit der Statistik-Software R kannst Du statistische Simulationen, Datenanalysen, aber auch Datenmanagement oder automatisierte Reports und Dashboards erstellen.
R ist völlig kostenlos und ein GNU-Projekt. Du kannst das Statistikprogramm R auf der offiziellen R-Projekt-Seite herunterladen. Es ist für Windows, MacOS und viele Unix-Varianten – unter anderem debian, redhat, suse und ubuntu – verfügbar.
R ist eine Interpreter-Programmiersprache, d.h. ein R-Skript wird Zeile für Zeile ausgeführt. Das Gegenteil ist eine Compiler-Programmiersprache wie C++, welche das gesamte Skript nimmt und in eine maschinenlesbare Form (exe-Datei) bringt. Mit R ist das nicht möglich, d.h. man benötigt immer eine R-Installation, um ein R-Skript laufen zu lassen.
Was sind R-Packages?
R besitzt umfangreiche Erweiterungen, sogenannte Packages. Diese statten R mit vielen zusätzlichen Fähigkeiten aus, vom Datenmanagement über spezielle statistische Algorithmen bis zu umfangreichen Grafikbibliotheken. Aktuell gibt es über 12.000 Packages zum kostenlosen Herunterladen. In meinem kostenlosen eBook „Powertricks für das Datenmanagement mit R“ beschreibe ich die 10 wichtigsten Packages für das Datenmanagement und gebe einfache Beispiele.
Ein Package wird in R mit dem Befehl install.packages(„paketname“) heruntergeladen und installiert. Das muss man einmalig machen. Danach kann das Package über library(paketname) in das aktuelle Skript eingebunden werden.
Man spricht von Base-R, wenn eine Funktion in der Basisinstallation von R dabei ist.
Statistik mit R
R wurde ja entwickelt, um Statistikprogramme zu schreiben. Insofern gibt es schon in der Basisinstallation von R viele Funktionen, die für statistische Auswertungen verwendet werden können. Hier einige Beispiele:

# erstellt eine normalverteilte Stichprobe mit n=100
x &lt;- rnorm(100)

## einige deskriptive Statistikmethoden
# Mittelwert
mean(x)
# Standardabweichung
sd(x)
# Varianz
var(x)
# Minimum
min(x)
# Maximum
max(x)
# Wertebereich
range(x)
# Median
median(x)

# Lineare Regression
#Stichprobe erstellen
n &lt;- 100
x &lt;- rnorm(n)
y &lt;- 2 + 3*x + rnorm(n,0,0.5)

l &lt;- lm(y ~ x)
l
summary(l)

#statistische Tests
n &lt;- 100
x &lt;- rnorm(n)
y &lt;- rt(n,1)
t.test(x,mu=2) #Test, ob Mittelwert=2
t.test(x,y) #Test, ob Mittelwert von x und y gleich
shapiro.test(y) #Test auf Normalverteilung

12345678910111213141516171819202122232425262728293031323334353637

# erstellt eine normalverteilte Stichprobe mit n=100 x &lt;- rnorm(100) ## einige deskriptive Statistikmethoden# Mittelwertmean(x)# Standardabweichungsd(x)# Varianzvar(x)# Minimummin(x)# Maximummax(x)# Wertebereichrange(x)# Medianmedian(x)  # Lineare Regression#Stichprobe erstellenn &lt;- 100x &lt;- rnorm(n)y &lt;- 2 + 3*x + rnorm(n,0,0.5) l &lt;- lm(y ~ x)lsummary(l) #statistische Testsn &lt;- 100x &lt;- rnorm(n)y &lt;- rt(n,1)t.test(x,mu=2) #Test, ob Mittelwert=2t.test(x,y) #Test, ob Mittelwert von x und y gleichshapiro.test(y) #Test auf Normalverteilung

RStudio –  Die Standard R IDE
Wenn Du R installiert hast, kannst Du eigentlich direkt loslegen. Es lohnt sich aber, zusätzlich eine Entwicklungsumgebung zu installieren. IDE steht übrigens für „integrated development environment“. Vielleicht kennst Du ja schon Visual Studios oder Eclipse. Eine Entwicklungsumgebung hilft Dir beim Programmieren, indem es nützliche Ansichten und Werkzeuge bereitstellt. So bieten IDEs meistens eine Variablenansicht, also eine Tabelle mit allen Variablen, die verwendet wurden. Besonders effizient ist die automatische Vervollständigung, d.h. wie in Google zeigt Dir die IDE Ergänzungsvorschläge an, wenn Du den Anfang eines Befehls getippt hast. Damit wird das Programmieren deutlich schneller.
Die de facto Standard-IDE für R ist RStudio. Mittlerweile gibt es aber auch Visual Studio for R und auch Eclipse StatET
Von RStudio gibt es eine Desktop- und eine Serverversion. Die Desktopversion gibt es für Windows, MacOS und die Standard-Linux-Distributionen (Ubuntu, Debian, Fedora, Redhat, Suse). Neben der OpenSource-Version, die für die meisten von uns in Frage kommt, gibt es noch eine Commercial Licence für 1000$/Jahr, welche Priority Support bietet.
Die Serverversion gibt es nur für Linux. Diese benötigt man, wenn man R auf einem Server laufen lassen möchte und darauf per RStudio IDE über einen Webbrowser zugreifen möchte. Auch von RStudio Server gibt eine eine kostenlose OpenSource-Version und eine kommerzielle Version. Im Gegensatz zur Desktop-Version bietet aber die kommerzielle Version viele zusätzliche Tools wie LoadBalance, Monitoring und viele weitere Admin-Tools. Das hat allerdings auch seinen Preis, dafür sind nämlich 10.000$ im Jahr fällig. Sinnvoll also nur für Firmen, die diese Infrastruktur benötigen.
Aktuell arbeite ich mit einer ganz normalen R Desktop OpenSource-Version, welche auf einem Server läuft, auf den ich ganz simpel per RemoteDesktop zugreife. Ganz simpel, einfach aufzusetzen und genügt für fast alle Anwendungen. Zusammen mit Shiny Server, welcher für die Bereitstellung von Dashboards benötigt wird, ist das schon ein ganz mächtiges System.
Glossar: rnorm min Neuronales Netz Maschinelles Lernen RStudio mean median

Loading

Newsletter

Immer informiert

Melde Dich zu meinem Newsletter an, der News, Angeboten und Eventeinladungen aus dem deutschen Data Science-Universum enthält.

Du erhältst mit dem Eintrag als DANKESCHÖN mein E-Book „Power-Tricks für das Datenmanagement in R“.

Du bist noch einen Schritt vom Ebook entfernt. Ich habe Dir soeben eine Email geschickt. Bitte klicke auf den dort hinterlegten Link.