Integration von XGBoost in SAP HANA Analysen mithilfe von R

Nachdem die technische Integration von R in http://blog.five1.de/installation-von-r-fur-die-verwendung-mit-sap-hana/ von Marcel Salein beschrieben wurde, möchte ich einen kleinen Überblick über die Möglichkeiten der Schnittstellen zeigen.

Vorbereitung

Installieren von R Paketen auf dem R-Server

Doch bevor es losgeht, müssen noch einige Packet Abhängigkeiten geklärt werden. Zur Durchführung dieses Beispiels, muss die Bibliothek xgboost auf dem R-Server installiert werden. Die Installation der Bibliothek erfolgt dabei über die Kommandozeile des R-Servers.

# killall -INT Rserve
# R
> install.packages("xgboost")
> library("xgboost")
> quit()
# R CMD Rserve --RS-port 30120 --no-save --RS-encoding "utf8"
# exit

Timeoutparameter für R Prozesse

Je nach implementierten R-Prozess, muss der Parameter cer_timeout, in der HANA Konfiguration angepasst werden. Der Standardwert beträgt 300s. Je nach Analyse ist es Sinnvoll, den Timeoutparameter auf > 3600s zu setzten. Z. B. dauert das Trainieren eines XGBoost-Modells mit 1 Millionen Datensätzen und 1000 Iterationen auf einer zwei Kern Maschine, 20 Minuten. Dazu kommt noch die Zeit der Datenübertragung. Diese fällt einerseits beim Transfer der Inputdaten von HANA auf den R-Server und andererseits beim Transfer der Ergebnistabellen zurück in die HANA Instanz an.

Entwickeln von R Applikationen../../Graph/HANA_R_Integration_Prototype.png

Die Möglichkeiten der Fehlersuche in R-Prozeduren über das HANA Studio sind relativ begrenzt. Für die effiziente Entwicklung und Fehlersuche in R-Applikationen ist die Nutzung einer R-IDE unumgänglich. Der Quasistandard für die Entwicklung ist das R-Studio.

Einrichten der lokalen Entwicklungsumgebung

R-Studio ist eine plattformunabhängige IDE, welche den R-Kern mit ausliefert. Nach der Installation, können über die R-Konsole nötige Pakete nachinstalliert werden. Um eine JDBC Verbindung zu SAP HANA aufbauen zu können, wird das Packet “RJDBC“ benötigt. Dies kann über den Befehl

> install.packages(’RJDBC’)

installiert werden. Nach der Installation, kann über den Befehl

> library('RJDBC')

die Library geladen werden. Kommt an der Stelle keine Ausgabe, war die Installation erfolgreich.

Damit R über RJDBC auf die HANA zugreifen kann, muss der JDBC Treiber im System installiert sein. Der JDBC Treiber wird entweder mit dem HANA Studio, oder dem Data Provisioning Agent ausgeliefert.

OS Installation Pfad
WINDOWS HANA Studio C:\Program Files\sap\hdbclient\ngdbc.jar
UNIX Data Provisoning Agent ../dataprovagent/configuration/org.eclipse.osgi/
bundles/17/1/.cp/lib/com.sap.db.ngdbc.jar

Für den Aufbau der JDBC Connection, müssen die Parameter der Verbindung spezifiziert werden.

#Set db parameter
db <- '<IP-HANA>:<PORT>'
schema <- '<SCHEMANAME>'
#Set credentials for db
dbuser <- '<USERNAME>'
dbpw <- '<PASSWORD>'
#Set driver location
driverlocation <- "/Users/…/ngdbc.jar"
#set up jdbc connection with ngdbc.jar driver, provided by SAP
##load driver
jdbcDriver <- JDBC(driverClass="com.sap.db.jdbc.Driver",
classPath=driverlocation)
##set up db conenction
jdbcConnection <- dbConnect(jdbcDriver,
sprintf("jdbc:sap://%s/?currentschema=%s",db,schema),
dbuser,
dbpw)

Prototyping

Ziel des Prototypings ist es, eine lauffähige Analyse zu entwickeln, die auf einer deutlich kleineren Datenmenge erfolgen kann. Für das Training und den Test des XGBoost Algorithmus werden aus zwei Tabellen Subsets geladen:

train_raw <- dbGetQuery(jdbcConnection, 'SELECT TOP 1000 * FROM "<SCHEMA>"."MODEL_TRAIN"')
test_raw <- dbGetQuery(jdbcConnection, 'SELECT TOP 500 * FROM "<SCHEMA>"."MODEL_TEST"')

Im nächsten Schritt werden die Daten in die nötige Struktur gebracht.

train.data <- data.matrix(train_raw[,!(colnames(train_raw) %in% c("Customers"))])
train.label <- data.matrix(train_raw[,"Customers"])
test.data <- data.matrix(test_raw[,!(colnames(test_raw) %in% c("Customers"))])
test.label <- data.matrix(test_raw[,"Customers"])

Danach erfolgt das Training des Modelles.

clf <- xgboost(data = train.data, label = train.label, max_depth = 10,
eta = 0.015, nthread = 4, nrounds = 1000, objective = "reg:linear")

Darauf basierend, wird für den Test der Vorhersagegüte, eine Vorhersage auf einem Testdatensatz durchgeführt.

test.pred <- predict(clf, test.data)

Am Ende der Entwicklung sollte ein lauffähiger Analyseflow stehen.

Deployment von R Applikationen

../../Graph/HANA_R_Integration_Deployment.png

Transformation des Prototyps zu einer Stored Procedure

Der oben entwickelte Prototyp, muss für die Verwendung als Prozedur, in der Hana angepasst werden. U.a. erfolgt das Laden der Daten in die R-Instanz, nicht mehr über die R-seitige JDBC Verbindung, sondern über die Integration vom R-Server in der HANA.

Das Grundgerüst der Stored Procedure sieht wie folgt aus:

CREATE PROCEDURE XGBOOST(<INPUT TABLES>, <OUTPUT TABLES>)
LANGUAGE RLANG AS
BEGIN
<R CODE>
END;

Der Prototyp benötigt in diesem Fall zwei Tabellen und generiert eine Output Tabelle. Die Parameterdefinition der Prozeduren ergibt sich wie folgt:

CREATE PROCEDURE XGBOOST(IN train "<Schema>"."MODEL_TRAIN", IN test "<Schema>"."MODEL_TEST", OUT result "<Schema>"."FORCAST_TEST")

Der Body der Prozedur, folgt aus dem Hauptteil des Prototyps. Angepasst werden müssen vor allem die Namen der Quelltabellen.

library(xgboost)
train.data <- data.matrix(train[,!(colnames(train) %in% c("Customers"))])
train.label <- data.matrix(train[,"Customers"])
clf <- xgboost(data = train.data, label = train.label, max_depth = 10, eta = 0.015,
nthread = 2, nrounds = 1000, objective = "reg:linear")
test.data <- data.matrix(test[,!(colnames(test) %in% c("Customers"))])
prediction <- data.frame(predict(clf, test.data))
result <- cbind(test, prediction)
colnames(result)[-1] <- "Customers"

Die letzten zwei Zeilen bauen die Struktur für die Outputtabelle auf. Wichtig ist, dass alle Spalten in der Outputtabelle benannt sind.

Integration der Stored Procedure in ein SQL Script

Die Integration der oben entwickelten Stored Procedure wird in zwei Schritten in SQL Script eingebettet.

Der erste Schritt ist die Erstellung der Zieltabelle und das Löschen einer etwaig vorhandenen Prozedurversion.

DROP TABLE "<SCHEMA>"."FORCAST_TEST";
CREATE COLUMN TABLE "<SCHEMA>"."FORCAST_TEST" LIKE "<SCHEMA>"."MODEL_TEST"
WITH NO DATA;
ALTER TABLE "<SCHEMA>"."FORCAST_TEST" ADD (PRED INT);
DROP PROCEDURE XGBOOST;

Der zweite Teil ist der Call der Prozedur.

CALL XGBOOST("<SCHEMA>"."MODEL_TRAIN", "<SCHEMA>"."MODEL_TEST",
"<SCHEMA>"."FORCAST_TEST") WITH OVERVIEW;

Das resultierende Script sieht nach der Entwicklung wie folgt aus:

DROP TABLE "<SCHEMA>"."FORCAST_TEST";
CREATE COLUMN TABLE "<SCHEMA>"."FORCAST_TEST" LIKE "<SCHEMA>"."MODEL_TEST"
WITH NO DATA;
ALTER TABLE "<SCHEMA>"."FORCAST_TEST" ADD (PRED INT);
DROP PROCEDURE XGBOOST;
CREATE PROCEDURE XGBOOST(IN train "<SCHEMA>"."MODEL_TRAIN", IN test
"<SCHEMA>"."MODEL_TEST", OUT result "<SCHEMA>"."FORCAST_TEST")
LANGUAGE RLANG AS
BEGIN
library(xgboost)
train.data <- data.matrix(train[,!(colnames(train) %in% c("Customers"))])
train.label <- data.matrix(train[,"Customers"])
clf <- xgboost(data = train.data, label = train.label, max_depth = 10,
eta = 0.015, nthread = 2, nrounds = 1000, objective = "reg:linear")
test.data <- data.matrix(test[,!(colnames(test) %in% c("Customers"))])
prediction <- data.frame(predict(clf, test.data))
result <- cbind(test, prediction) colnames(result)[-1] <- "Customers"
END;
CALL XGBOOST("<SCHEMA>"."<SCHEMA>_TRAIN", "<SCHEMA>"."MODEL_TEST",
"<SCHEMA>"."FORCAST_TEST") WITH OVERVIEW;
SELECT * FROM "<SCHEMA>"."<SCHEMA>_TEST";

Zusammenfassung

Die R-Integration bietet über die Verwendung von RLANG Prozeduren die Möglichkeit die flexible Welt der R-Analyse, in die Infrastruktur der HANA zu integrieren. Dabei müssen zwei Bereiche beachtet werden:

  • Der größte Teil des Preprocessings sollte in der HANA Datenbank erfolgen, um den Vorteil der Datenbank voll auszuschöpfen.
  • Die Integration von R hat zur Folge, dass die Inputtabellen in den R-Server übertragen werden. Dieser muss groß genug dimensioniert sein, um die Datenmenge im RAM zu halten, da sonst auf Seiten des R-Servers, die Verarbeitungsgeschwindigkeit beeinflusst.

Im nächsten Blogbeitrag, wird die Integration von Hana und Tensorflow über R im Fokus stehen. Bis dahin viel Spaß bei Analysen mit der R Integration.

Getagged mit: , , , , , , ,

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.

*

*