Webinar: Predictive Analytics mit Azure

Innovation mit Microsoft Azure: Data Analytics

Natürlich hätten wir Sie viel lieber zu unseren beliebten Technical Councils ins SDX Office eingeladen; leider ist dies immer noch nicht möglich.

Herzlich Willkommen deshalb zu unserem Microsoft Azure Live Meeting “Predictive Analytics mit Azure”.

Die Session ist kompakt auf remote-gerechte 60 Minuten ausgelegt und findet als Microsoft Teams-Event statt (per App oder Browser). Nach Anmeldung erhalten Sie die nötigen Zugangsdaten.

.

Agenda

  • Architektur: Big Data und Analytics beherrschen
  • Hosted on Azure: Microsoft- und Open Source-Technologien
  • Use Case: Markttrendanalyse auf der Basis von Twitter- und Finanzmarktdaten
    (Azure Event Hub, Azure Databricks, Cognitive Services, Power BI)
  • Azure-Kostenübersicht und Optimierungsoptionen
  • Optionen, Erfahrungen und Empfehlungen

.

Referenten

  • Christoph Sauer, Principal eXpert
  • Dr. Martin Pieroth, Senior eXpert

.

Zielgruppe

Entscheider, Architekten, Data Engineers

.

Datum

Dienstag, 01.12.2020 um 11:00-12:00 Uhr

.

Anmeldung

Anmeldung per E-Mail an Innovation@sdx-ag.de

.

Technologie pur – versprochen  🙂

Wer uns kennt, weiß, dass wir in unseren Vorträgen tatsächlich kein Marketing machen, sondern technisches Know-How kompetent weitergeben. Denn alle Speaker sind als Microsoft Technologie Spezialisten im Tagesgeschäft in entsprechenden Enterprise Projekten aktiv.
Melden Sie sich an und überzeugen sich selbst!

Unsere eXperts freuen sich auf Ihre Teilnahme und einen spannenden Austausch.

Gerne können Sie die Innovations-Themen individuell für Ihr Team buchen, weitere Infos auch unter Predictive Analytics • Cloud-Migration • .NET Core • Microservices • MAUI • Serverless.

Kostenoptimierte Azure Data-Analytics-Architekturen (Workshop)

Planen Sie Green-Field-Projekte im Bereich Data Analytics, die Entwicklung einer Data-Analytics-Plattform, ein Refactoring oder die Cloud-Migration vorhandenen Data-Analytics-Landschaften?

Wenn ja, bietet Ihnen unser zweiwöchiger Workshop zur Analyse und Konzeption von kostenoptimierten Data-Analytics-Architekturen (in Azure oder hybrid) einen echten Mehrwert, siehe Azure Marketplace

Zusätzlich ist situativ ein Funding bei Nutzung innovativer Azure-Services möglich 😊
Interessiert? Kontaktieren Sie uns gerne über Innovation@sdx-ag.de!

SDX Data Analytics Referenzarchitektur

Getting Started with Machine Learning – Data Science

Nachdem ich im ersten Teil meines Artikels auf die Plattform Kaggle, Explorative Datenanalyse, Feature Engineering und Data Cleansing eingegangen bin, möchte ich in diesem Artikel beschreiben, wie man einen Machine Learning Algorithmus auswählt, Parameter optimiert und ein Modell erstellt, trainiert und anwendet.

Auswahl des Machine Learning Algorithmus

Die Auswahl hängt sehr stark von der Fragestellung und den vorhandenen Daten ab. Beim ausgewählten Use-Case, der Microsoft Malware Prediction, handelt es sich um eine Binary Classification, mögliche Ausprägungen sind die booleschen Werte „True“ und „False“. Für diese Art der Klassifikation eignen sich einige Algorithmen, unter anderem Support Vector Machine (SVM), Logistische Regressionen, Neuronale Netze oder Entscheidungsbäume. Ein Cheat-Sheet, das bei der Auswahl unterstützt, kann von Microsoft heruntergeladen werden.

In meinem Fall fiel die Wahl auf LightGBM, ein Gradient Boosting Framework, das auf Decision-Tree-Algorithmen basiert. Der Algorithmus wurde im Jahr 2017 von Microsoft veröffentlicht. LightGBM bringt einige Vorteile mit sich, wie GPU-Support, gute Genauigkeit, schnelles Training, Unterstützung zeichenkettenbasierter Features, Umgang mit großen Datenmengen, sklearn-API und Unterstützung von Pandas DataFrames.

Das Ergebnis, ein Entscheidungsbaum, kann man anzeigen und damit nachvollziehen, wie die Daten interpretiert wurden und wie das Modell zu Stande kommt. Das LightGBM-Git-Repository unterliegt der Microsoft Code of Conduct, das bedeutet, Microsoft überwacht die Weiterentwicklung des Frameworks.

Im Gegensatz zu normalen Entscheidungsbäumen ist LightGBM nicht Level-, sondern Leaf-basiert. Leaf-basierte Algorithmen konvergieren schneller, sind allerdings anfälliger für Overfitting. Beim Umgang mit kleinen Datenmengen sollte man nicht unbedingt auf diesen Algorithmus zurückgreifen.

Abbildung 1: Level-based tree
Abbildung 2: Leaf-based tree

Die Auswahl eines Leafs wird über die maximale Delta Loss getroffen.

Data Preparation

Im ersten Teil des Artikels habe ich bereits die Daten zur Verwendung vorbereitet. LightGBM unterstützt auch String-Werte, sofern die Features vom Datentyp „Category“ sind. Ein Label Encoding ist also nicht weiter notwendig. Die Transformation der kategorischen Werte in den Datentyp „Category“ muss allerdings noch vorgenommen werden, bevor man Modelle erstellen und trainieren kann. Einige Strings sind teilweise groß- und kleingeschrieben, deshalb werden alle Großbuchstaben in kleine Buchstaben umgewandelt. Die Transformationen des Datentyps und die Groß- und Kleinschreibung werden für alle Features durchgeführt, die nicht vom Datentyp „float“ sind.

numeric_features = []
categorical_features = []

numeric_features = [key for key in types if types[key] == 'float64']
categorical_features  = [key for key in types if types[key] != 'float64']

for cat in categorical_features:
    train_df[cat] = train_df[cat].apply(lambda x: str(x).lower())
    test_df[cat] = test_df[cat].apply(lambda x: str(x).lower())

train_df = changeType(train_df,categorical_features,'category')
test_df = changeType(test_df,categorical_features,'category')

Parameter

LightGBM bietet viele verschiedene Parameter, die zur Feinabstimmung des Algorithmus eingesetzt werden können. In der Regel kann man mit den Default-Einstellungen akzeptable Ergebnisse erzielen.  Nichtsdestotrotz lohnt es, sich mit den verschiedenen Parametern auseinanderzusetzen.

Je nach Einstellung können Modelle auf Geschwindigkeit oder Genauigkeit optimiert werden. Versucht man die Trainingsgeschwindigkeit zu optimieren, so kann man das „Bagging“ anpassen. Die „bagging_fraction“ bestimmt, welcher Teil der Daten für eine Iteration verwendet werden soll. Per Default werden alle Trainingsdaten verwendet (bagging_fraction == 1.0). Daneben kann auch die „Feature Fraction“ angepasst werden. Setzt man die „feature_fraction“ auf 0.8, so werden nur 80% aller Features verwendet. Die Auswahl der Features wird für jede Iteration neu getroffen und ist zufällig. Daneben sollte man die „max_bin“ (Anzahl Buckets) auf einen kleinen Wert setzen.

Liegt das Augenmerk auf der Steigerung der Genauigkeit, sollte der Parameter „max_bin“ auf einen großen Wert gesetzt werden. Weitere Parameter, die die Genauigkeit positiv beeinflussen, sind „learning_rate“ und „num_iterations“. Zur Verbesserung setzt man die „learning_rate“ auf einen kleinen Wert, „num_iterations“ dagegen auf einen großen Wert. Die Learning Rate bestimmt die Gewichtung der neuen Bäume. Der Parameter „num_iterations“ bestimmt, wie viele Bäume maximal erstellt werden. Um Zeit zu sparen empfiehlt es sich, „Early Stopping“ zu verwenden. Über „early_stopping_round“ lässt sich das Training automatisch stoppen, sofern sich das Modell nicht innerhalb von N Iteration verbessert. Darüber hinaus sollte „num_leaves“ auf einen großen Wert gesetzt werden. Bei dieser Einstellung ist Vorsicht geboten, Anpassungen können zu Overfitting führen.

Weitere wichtige Parameter sind „device“ (CPU oder GPU), „Metrik“ (mae, mse, multi_logloss und binary_logloss), „categorical_feature” (Spaltenindex der kategorischen Features) und „objective“ (u. a. binary für Binary Classification).  

Hyperparameter Tuning (Grid Search)

Das Setup der Parameter kann zum Teil mit Grid Search automatisiert werden. Grid Search sucht nach der optimalen Abstimmung der Parameter. LightGBM bietet eine API für die Bibliothek sklearn und die Klasse „GridSearchCV“. Der Programmieraufwand ist an der Stelle folglich gering. „GridSearchCV“ erwartet die zu überprüfenden Parameter mit Ausprägungen und einen initialisierten Classifier. Nach erfolgreicher Ausführung werden die besten gefundenen Parameter bzw. die Kombination, die zum besten Ergebnis geführt hat, ausgegeben.

params = {'boosting_type': 'gbdt',
          'max_depth' : -1,
          'objective': 'binary',
          'num_leaves': 64,
          'learning_rate': 0.05,
          'n_estimators': 100,
          'max_bin': 15,
          'reg_alpha': 0.0,
          'reg_lambda': 0.0,                    
          'metric' : 'auc'}

param_grid = {
'num_leaves': [150, 650, 1150],    
'learning_rate': [0.1, 0.03, 0.2],
'max_bin': [50, 80, 170, 255],
'n_estimators': [100, 900, 1800],
'max_depth': [-1, 15, 65],
'reg_alpha' : [0.7, 1, 1.3],
'reg_lambda' : [0.7, 1, 1.3]
}

estimator = lgb.LGBMClassifier(
          silent = True,
          verbose_eval=10,
          early_stopping_rounds=10,
          device_type='cpu',
          gpu_device_id=0,
          gpu_platform_id=0,
          random_state=2019,                    
          objective = params['objective'],          
          boosting_type= params['boosting_type'],
          num_leaves = params['num_leaves'],
          learning_rate = params['learning_rate'],
          metric = params['metric'],
          reg_alpha = params['reg_alpha'],
          reg_lambda = params['reg_lambda'],                    
          max_bin = params['max_bin'])

scoring = 'roc_auc'
grid = GridSearchCV(estimator, param_grid,
                    verbose=1,
                    scoring=scoring,
                    refit=True,
                    cv=2,
                    n_jobs=-1)

lgb_model = grid.fit(X_train, y_train, eval_set=(X_test, y_test))
print(lgb_model.best_params_, lgb_model.best_score_)

Cross Validation (KFold)

Speziell Entscheidungsbäume sind anfällig für Overfitting. Durch Hyperparameter Tuning steigt die Gefahr von Overfitting. Im Falle von Overfitting weist das Modell hohe Genauigkeit bei den Trainingsdaten auf, nicht aber bei der Gesamtdistribution.

Ursachen sind unter anderem fehlerhafte Trainingsdaten, Ausreißer oder eine zu kleine Trainingsmenge.

Zur Reduzierung von Overfitting kann man Cross Validation einsetzen. Auch für diesen Zweck bietet sklearn ein Modul an, „StratifiedKFold“. Es liefert Indizes zum Splitten eines Datasets in Trainings- und Testdatenset. Ein Split wird auch Fold genannt. Das Verhältnis der Daten ergibt sich aus der Anzahl Folds (1/K). Bei drei Folds (1/3) ergibt sich ein Verhältnis von 67% Trainingsdaten zu 33% Testdaten. Das Splitting wird mehrmals durchgeführt, per Default dreimal (ab v0.22 fünfmal). Nach jedem Split wird ein Modell erstellt und trainiert. Nachdem das Training abgeschlossen ist, kann man bewerten, welcher Fold zum besten Ergebnis geführt hat.

kfold = 5
skf = StratifiedKFold(n_splits=kfold, shuffle=True)

for i, (train_index, test_index) in enumerate(skf.split(train_df, train_label)):
    evals_result = {}
    print(' lgbm kfold: {}  of  {} : '.format(i+1, kfold))
    print(i)
    print(train_index)
    print(test_index)

Modell Training

Nach erfolgreicher Durchführung des Hyperparameter Tunings liegen geeignete Parameter für den Algorithmus vor. Aus der Cross Validation geht ein Trainings- und ein Testdatenset mit einem geeigneten Verhältnis hervor.

Die Datasets liegen in Form von Pandas Datasets vor, zur Modellerstellung werden daraus zwei LightGBM Datasets erzeugt. Ein LightGBM Dataset erwartet neben den Features, die Labels, die Featurenamen und eine Liste mit den Namen der kategorischen Features.

dtrain = lgb.Dataset(X_train, label=y_train, 
                    feature_name=feature_names, 
                    categorical_feature=categorical_features)
dtest = lgb.Dataset(X_test, label=y_test, 
                    feature_name=feature_names, 
                    categorical_feature=categorical_features)

Damit sind die Vorbereitungen abgeschlossen und ein Modell kann erstellt und trainiert werden. Die Methode für diesen Zweck heißt „train“. Die Methode erwartet Parameter, Anzahl der Iterationen, ein Trainingsdatenset und zur Validierung ein Testdatenset.

param = {}
param['metric'] = 'auc'
param['max_depth'] = -1
param['max_bin'] = 255
param['num_leaves'] = 150
param['objective'] = 'binary'
param['device_type'] = 'cpu'
param['boosting'] = 'gbdt'
param['learning_rate'] = 0.03
param['reg_alpha'] = 0.7
param['reg_lambda'] = 1.3

num_iterations = 1500

bst = lgb.train(param, 
                dtrain, 
                num_iterations, 
                valid_sets=[dtest], 
                evals_result=evals_result, 
                early_stopping_rounds=10, 
                verbose_eval=100)

Nach abgeschlossenem Training kann das trainierte Modell gespeichert werden. LightGBM bietet zur Persistierung eine Methode („dump_Model“), die das Modell im JSON-Format speichert. Neben der Built-In-Funktionalität gibt es die Möglichkeit, Modelle im Binärformat mit dem Modul „joblib“ zu persistieren und zu laden.

import joblib
joblib.dump(bst, 'predictmalware.pkl')

bst = joblib.load('predictmalware.pkl')

Modell Evalution

Während des Trainings werden die Ergebnisse (AUC) im Intervall von 100 Iterationen ausgegeben („verbose_eval“). Sofern sich das Modell innerhalb von zehn Iterationen nicht verbessert, wird das Training abgebrochen und die beste Iteration ausgewählt („early_stopping_rounds“).

Abbildung 3: Konsolenausgabe Trainingsfortschritt

Die Lernkurve kann man sich nach erfolgreichem Training als Plot ausgeben lassen. Im Plot werden die Iterationen und die ausgewählte Metrik (AUC) angezeigt.

Abbildung 4: Trainingsfortschritt AUC

Neben dem Trainingsfortschritt gibt es noch weitere Informationen, die man sich per Plot ausgeben lassen kann, unter anderem den Entscheidungsbaum und die Bedeutung der einzelnen Features. Der Entscheidungsbaum ist bei 81 Features sehr mächtig und schwer lesbar. Im Rahmen einer Auditierung kann es dennoch ein nützliches Instrument sein.

Im Nachfolgenden wird die Bedeutung der einzelnen Features grafisch dargestellt. Das Feature „Date“, das im Zuge des Features Engineerings (siehe Artikel 1) erzeugt wurde, spielt bei der Modellerstellung eine wichtige Rolle.

Abbildung 5: Feature Importance

Predict Values

Ein trainiertes Modell wird dazu verwendet, um Daten zu bewerten. Bewertungen werden auf Eingangsdaten mit der Methode „predict“ getroffen. Bei diesem Schritt ist zu beachten, dass die Eingangsdaten strukturell zum Modell passen müssen. Die Struktur wird durch die Trainingsdaten vorgegeben. Für den Parameter „num_iteration“ sollte die Iteration mit dem besten Ergebnis gewählt werden. Als Ergebnis liefert die Methode „predict“ ein Numpy-Array mit float-Werten im Wertebereich von 0,0 bis 1,0. Werte die größer als 0,5 sind, können dem Label „True“ zugeordnet werden, kleinere dem Label „False“.

predictions = bst.predict(test_df, num_iteration=bst.best_iteration)

Fazit

Aufmerksam wurde ich auf den Algorithmus durch Kaggle. Im Vergleich zu anderen Algorithmen performt LightGBM gut. Positiv ist mir auch die Trainingsgeschwindigkeit aufgefallen. Mit GPU-Training wäre es sicher noch schneller gegangen. Die Schnittstellen ermöglichen einfache Einbindung gängiger Module und ersparen zusätzlichen Programmieraufwand.

Mit der Verwendung von „GridSearchCV“ kann man die Suche nach einem guten Parameterset sehr stark automatisieren. Dabei ist zu beachten, dass „GridSearchCV“ alle möglichen Parameter-Kombination durchprobiert, je nach Anzahl Parameter und Ausprägungen kann die Zahl der Ausführungen groß werden und der Prozess sehr langwierig sein.

Auch der eigentliche Trainingsprozess kann je nach Größe der Trainingsdaten und Hyperparametern sehr lange dauern. Allgemein ist es ratsam, rechenintensive Prozesse, wie Training und Hyperparameter-Tuning, in eine virtuelle Maschine auszulagern. Eine andere Möglichkeit ist die Verwendung von Azure Machine Learning Service. Mit diesem Service lässt sich Rechenleistung nach Bedarf beziehen und ein trainiertes Modell als Web Service bereitstellen. Durch Einbindung in einen Web Service wird der Modellzugriff flexibel und einfach.

Getting Started with Machine Learning – Data Engineering

In diesem Artikel möchte ich skizzieren, wie man sich dem Thema Machine Learning (ML) nähern und Wissen aufbauen kann. Dabei werde ich verschiedene Teilschritte anschneiden, die im Prozess der Modellerstellung relevant sind. Insbesondere geht es im ersten Teil um die Vorbereitung der Daten. Als durchgehendes Beispiel dient eine Kaggle Competition, die von Microsoft veröffentlicht wurde.

Kaggle

Kaggle ist eine Online-Plattform für Data Scientists und gehört zu Google. Über die Plattform werden Datasets und ML-Competitions angeboten, an denen angemeldete User teilnehmen können. Einige Competitions sind mit einem Preisgeld versehen, das unter den Teilnehmern mit den besten Ergebnissen ausgeschüttet wird. Bereitgestellt werden die Competitions von den unterschiedlichsten Unternehmen. Die Branchen reichen von Banken bis hin zu wissenschaftlichen Einrichtungen, die zum Beispiel an Hautkrebserkennung forschen.

Neben dem Wettbewerb dient Kaggle auch als Social Media Plattform. User können über die Website ihre Ergebnisse mittels sogenannter Kernels interaktiv präsentieren und so mit Anderen in Kontakt treten und Wissen teilen. Wenn man sich dem Thema Machine Learning bzw. Data Science annähern möchte, ist Kaggle ein guter Weg. Die Kernels liefern Hilfestellung, wie Daten transformiert und angereichert werden können. Daneben bekommt man Informationen, welche ML-Algorithmen am Markt gängig sind und gut performen.

Microsoft Malware Prediction

Microsoft hat in Zusammenarbeit mit Northeastern University und Georgia Tech eine Competition mit dem Titel „Microsoft Malware Prediction“ auf Kaggle veröffentlicht. Die Aufgabe war es, anhand verschiedener Systemparameter, wie zum Beispiel die Version des Windows Defender oder der Windows Edition vorherzusagen, ob ein Gerät zukünftig von Schadsoftware infiltriert wird. Das Trainingsdatenset ist 4 GB groß und enthält 82 Features.

Entwicklungsumgebung

Die folgenden Schritte wurden auf einem lokalen Rechner mit 32 GB RAM durchgeführt. Auf dem Rechner ist eine Anaconda Distribution installiert, welche Pakete der Programmiersprachen Python und R beinhaltet. Im Wesentlichen wird Anaconda zur Verarbeitung von großen Datenmengen, Datenanalyse und wissenschaftlichem Rechnen verwendet. Pakete wie Pandas, Matplotlib oder scikit-learn werden direkt mitgeliefert, es bedarf keiner weiteren Installation.

Als Quelltext-Editor wurde Visual Studio Code mit der Extension „Python“ verwendet. Durch die Extension erhält man IntelliSense und die Möglichkeit, mit Jupyter Notebooks zu arbeiten. Jupyter Notebooks ermöglichen die Definition von „Code Cells“ und die Darstellung von Plots. Jede „Code Cell“ kann einzeln ausgeführt werden. Das Ergebnis wird in einem separaten Fenster dargestellt. In VS Code wird eine Code Cell mit folgenden Zeichen definiert: “#%%”. Als Python Interpreter wurde die zuvor installierte Anaconda Environment ausgewählt.

#%%
# Print Sample Text
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
print("Sample Text")

#%%
# Show Sample Plot
x = [x * 0.01 for x in range(0, 100)]
y = [x**2 for x in x]
plt.title(label='Sample Plot', color='#eae8ed')
plt.plot(x,y, color='#8c56bf')
Abbildung 1: Sample Plot

Explorative Datenanalyse

Im ersten Schritt geht es darum, die Daten zu verstehen und herauszufinden, ob es sich z. B. um nominale oder ordinale Daten, sogenannte kategorische Daten handelt. Diese müssen gegebenenfalls encodiert werden. Daneben gibt es quantitative Daten, die aus Messungen oder Zählungen hervorgehen. Weitere Fragestellungen sind unter anderem Verteilung der Daten, Korrelationen zwischen Feature und Zielvariable, Ausreißer oder Anzahl nicht befüllter Zeilen. In einem Datenset lassen sich in der Regel drei Arten von Qualitätsproblemen beobachten: fehlende Daten, fehlerhafte Datensätze und Ausreißer, sowie widersprüchliche Daten. Sie können das Ergebnis negativ beeinträchtigen.

Die Ausprägung der Zielvariable ist von großer Bedeutung und muss berücksichtigt werden. Sie ist maßgeblich für die Wahl des Algorithmus:

  • Ist die Zielvariable im Wertebereich von 1 und 0 (True oder False), sollte die Wahl auf einen Binary Classification Algorithmus fallen.
  • Muss man eine Instanz aus mehr als zwei Klassen (z.B. Drama, Komödie oder Thriller) wählen, empfiehlt sich ein Multiclass Classification Algorithmus.

Mit Python und Pandas DataFrames lassen sich Daten gut und einfach analysieren. Es bietet eine Menge Built-In-Funktionalität, mit der man Daten leicht und intuitiv in ein DataFrame einlesen und analysieren kann. Das Einlesen einer CSV-Datei sieht folgendermaßen aus:

import pandas as pd
train_df = pd.read_csv(r"Data\train.csv")

Die Abbildung 2 wurde mit Matplotlib (eine Python-Bibliothek für grafische Darstellungen) erstellt; sie wird für jedes kategorische Feature erzeugt. Gezeigt wird die Häufigkeit der verschiedenen Ausprägungen, gruppiert nach Zielvariable und Ausprägung. Ergänzt wird die Darstellung um ein paar Metadaten, wie z. B. die Anzahl der Null-Werte.

Beim Feature „SmartScreen“ fällt auf, dass innerhalb der Kategorien eine recht hohe Heterogenität herrscht und 36% aller Werte leer sind. Andere Features weisen sogar 99% leere Werte auf.

Abbildung 2: Barplot – Feature “SmartScreen”

Beim Blick auf das Corrplot wird deutlich, dass das Feature „SmartScreen“ trotz der vielen NULL-Werte die höchste Korrelation mit der Zielvariable aufweist; das Löschen des Features wäre also an dieser Stelle kontraproduktiv.

Abbildung 3: Corrplot

Data Engineering

Die zuvor beobachten Probleme (z. B. leere Werte oder Ausreißer) müssen behoben werden, um ein gutes Modell gewährleisten zu können.
Daneben müssen Features so angepasst werden, dass sie mit den verwendeten Algorithmen kompatibel sind. Einige können nicht mit String-Werten umgehen; diese müssen zuerst encodiert werden.

Für die Standardaufgaben gibt es Bibliotheken, die einem die Arbeit erleichtern. So bietet die Bibliothek scikit-learn einen Encoder für zeichenbasierte Werte. Im folgenden Codeblock werden alle kategorischen Features encodiert und deren Ausprägung in einen Int-Wert umgewandelt.

from sklearn import preprocessing
le = preprocessing.LabelEncoder()

for feature in categorical_features:
    train[feature = le.fit_transform(train_df[feature]).astype(str)

Microsoft hat zu den im Datenset enthalten Features eine Beschreibung beigefügt. Beim Feature „SmartScreen“ findet man eine Beschreibung, wie leere Werte ersetzt werden können. „If the value exists but is blank, the value “ExistsNotSet” is sent in telemetry.” Für das Feature „SmartScreen“ kann man also leere Werte durch die Ausprägung „ExistsNotSet“ ersetzen. Mit Python und Pandas lässt sich das in einer Zeile schreiben.

train_df['SmartScreen'] = train_df['SmartScreen'].fillna('ExistsNotSet')

Ein weiteres Feature im Dataset ist die „AvSigVersion“ (Anti Virus Signature Version), welche beispielsweise so aussieht: „1.275.552.0“. Microsoft veröffentlicht zu den Versionen die entsprechenden Zeitstempel, womit sich für jeden Datensatz ein Bezug zu der Zeit herstellen lässt. In der Community waren ein paar User so freundlich, die Versionen gegen den jeweiligen Zeitstempel zu mappen und das Ergebnis in einem Python Dictionary bereitzustellen. Im folgenden Codeblock werden Zeitstempel auf die Versionen gemappt und danach in das Date-Format transformiert.

datedictAv = np.load(r'Data\AvSigVersionTimestamps.npy')[()]
train_df['Date'] = train_df['AvSigVersion'].map(datedictAv)
train_df['Date'] = train_df['Date'].map(lambda x: x.date())

In Abbildung 4 wird ein Plot gezeigt, in dem die Summe aller positiven Labels (1 = hat Virus), gruppiert nach dem Datum, dargestellt wird. Es lässt sich beobachten, dass vor dem 23.07.2018 fast keine Einträge mit Malware-Erkennung vorhanden sind. Möglicherweise ist diese Information auch bedeutsam für das Modell.

Abbildung 4: Lineplot TimeSeries – Label “HasDetections”

Ein Beispiel für ein kontinuierlich quantitatives Feature im Datenset ist die „Census_PrimaryDiskTotalCapacity“ (Größe der primären Festplatte in MB). An ihr lässt sich skizzieren, wie man einen Ausreißer identifizieren und entfernen kann. Der maximale Wert dieses Features beträgt 8.160.436.745.562 MB, was ungefähr 8,16 Exabyte entspricht, ein Wert, der sehr wahrscheinlich nicht plausibel ist. Im folgendem Codeblock wird dargestellt, wie sich solche Ausreißer über den Median und die Standardabweichung suchen und eliminieren lassen.

max_value = train_df['Census_PrimaryDiskTotalCapacity'].median() + \
            train_df['Census_PrimaryDiskTotalCapacity'].std() * 0.1
min_value = 10000.0
# Drop rows with ouliers
train_df = \
    train_df.loc[(train_df['Census_PrimaryDiskTotalCapacity'] < max_value)\       
    &amp; train_df['Census_PrimaryDiskTotalCapacity'] > min_value)]

Eine andere Möglichkeit, den Umfang der Daten zu verringern und Störungen zu beseitigen, bietet die Normalisierung. Eine gängige Methode ist die Min-Max-Normalisierung. Bei dieser Methode werden die Daten linear in einen frei wählbaren Bereich, z. B. 0 bis 1, transformiert. In diesem Beispiel wird der maximale Wert auf 1 und der minimale Wert auf 0 geändert. Für diesen Prozess bietet scikit-learn ebenfalls eine entsprechende Klasse an, den „MinMaxScaler“.

Fazit

Die oben beschriebenen Schritte sind notwendig, um vorhandene Daten für ein Machine Learning Modell vorzubereiten. Der meiste Aufwand im Kontext von Machine Learning entfällt dabei auf die Datenanalyse und Data bzw. Feature Engineering. Mit Python, Pandas, Numpy, Matplotlib und scikit-learn erhält man gute Unterstützung und Built-In-Funktionalität, was die Arbeit durchaus komfortabel macht. Darüber hinaus ist der Einsatz von Visual Studio Code empfehlenswert. Durch IntelliSense steigt die Produktivität, mit Jupyter lassen sich Daten interaktiv untersuchen und darstellen.
Im zweiten Teil meines Artikels werde ich zeigen, wie man aus den zuvor bearbeiteten und transformierten Daten ein Modell erstellt. Dabei werde ich neben dem verwendeten Algorithmus (ein Boosted Decision Tree) zeigen, wie sich dessen Parameter mittels GridSearch optimieren lassen.

R-Integration in Power BI

Microsoft öffnet sich dieser Tage immer weiter Open-Source-Lösungen. Dieser Trend hin zur Integration von Open-Source-Software kann auch vermehrt im Cloudgeschäft beobachtet werden. Dort wird beispielsweise die Verwendung von Hadoop, Big Data-Lösung der Apache Foundation, angeboten. Im Zuge der Veröffentlichung von MS SQL SERVER 2016 wurde publik, dass dieser eine R-Integration enthält. Inzwischen integriert Microsoft R in Form der R Tools in Visual Studio und in Power BI. Was ist R und worin liegt der Mehrwert dieser Sprache?

R – Allgemein

R ist die am weitesten verbreitete statistische Programmiersprache, zählt rund 2 Millionen Anwender und ist Open-Source. Unter allen Programmiersprachen belegt R den sechsten Platz, im Vergleich der Jahre 2014 und 2015 hat R drei Plätze gewonnen.

Ranking

Abbildung 1: IEEE Top Programming Languages, 2015

Mit R können Daten analytisch aufbereitet und visualisiert werden. In der R-Bibliothek stehen über 7000 Pakete für Entwickler bereit. Daraus resultiert eine Vielzahl von Möglichkeiten, Analysen individualisiert aufzubauen. Zu den häufigsten R-Anwendern zählen Data Scientists, Statistiker und Analysten.

Power BI – Allgemein

Power BI ist ein Teil der Office 365-Suite. Das BI-Tool dient der Analyse und Visualisierung von Daten. Die Lösung ist nicht nur an IT-Anwender, sondern auch an Fachanwender gerichtet und steht somit im Kontext von Self-Service BI. Power BI konsolidiert Funktionen aus mehreren bestehenden BI Anwendungen, dabei vereint es bekannte Features aus Power Pivot, Power Query, Power Map und Power View in einer Anwendung.

Power BI – Entwicklung

Mit der Desktop Anwendung von Power BI lassen sich bequem Diagramme, Reports und Dashboards erzeugen. Im Gegensatz zu vorherigen Excel-Versionen, z.B. Excel 2010, sind die Funktionalitäten aus den oben genannten Add-Ins und Anwendungen bereits in der Desktop-Variante von Power BI integriert. Auf die Installation von Erweiterungen kann komplett verzichtet werden. Die komplette Funktionalität steht dem User nach der Installation Out-of-the-Box in vollem Umfang zur Verfügung. Aus der Anwendung heraus lassen sich die Ergebnisse in der Cloud bereitstellen, dadurch lassen sich Inhalte von überall mittels Browser oder Smartphones konsumieren. Für Power BI gibt es eine Android-, iPhone- und eine Windows 10 Mobile App. Power BI liefert eine Schnittstelle für den Report Server 2016 (SSRS) mit. Dadurch lassen sich Power BI-Inhalte einfach mit Reports vom Report Server konsolidieren und in einem Dashboard darstellen.

Power BI – Custom Visuals

Grafisch werden Daten in Power BI mittels Visuals ausgeprägt. Out-of-the-Box wird eine recht breite Palette an verschiedenen Visuals mitgeliefert. Relativ neu in Power BI sind die Custom Visuals. Dabei handelt es sich um Visuals, die von Mitgliedern der Power BI Community entwickelt sind. Dadurch, dass jeder Power BI Nutzer Visualisierungen erstellen und der Community zur Verfügung stellen kann, wächst die Anzahl neuer Visuals relativ schnell.

Im Allgemeinen wird die Funktionalität der Power BI Anwendung ständig erweitert, die Entwickler stellen monatlich neue Updates zum Download bereit. Wesentlicher Bestandteil dieser Updates sind zum Beispiel neue Gateways (Konnektoren). Mittels Gateways lassen sich bequem Daten aus Fremdsystemen importieren.

DataSourcesPowerBI

Abbildung 2: Data Sources Power BI, 2016

Durch die Integration einiger Konnektoren, unter anderem R oder Spark, wird das Analysepotential von Power BI erheblich gesteigert. Speziell mit der R-Integration wird dem Anwender ein mächtiges Werkzeug an die Hand gegeben, wenn es darum geht, Daten zu analysieren und neues Wissen zu generieren.

Entwicklung der R-Integration

Die R-Integration wurde erstmalig mit dem November 2015 Update ausgeliefert – damals noch im Beta Status. In Power BI stößt man an zwei Stellen auf die R-Integration. Dem Power BI Anwender wird einerseits angeboten Daten via R-Script zu importieren, andererseits besteht die Möglichkeit, die in Power BI befindlichen Daten, mittels R-Visualization und entsprechendem R-Script, als Grafik abzubilden.

Datenzugriff via ODBC-Schnittstelle

Bei der Migration von Daten kann aufgrund der Mächtigkeit und der Vielzahl der Pakete von R, auf einige Datenquellen zurückgegriffen werden. Sämtliche Textfiles und praktisch jede Datenbank lässt sich via ODBC (Open DataBase Connectivity) ansprechen. Die aufgerufenen Daten werden von R in sogenannte “data frames” gespeichert. Unter “data frames” versteht man eine Liste von Vektoren. Die Bearbeitung der Daten erfolgt durch Ansprache und Manipulation der “data frames”. Die Nutzung und Ausführung eines R-Skriptes setzt eine Installation von R, sowie die Installation der gewünschten Packages, voraus. Die R Installation muss von Power BI referenziert werden (siehe Anleitung). Um eine ODBC-Verbindung zu ermöglichen, muss im R-Studio die Bibliothek “RODBC” geladen werden.

R-Package Installation

Die Notation zur Installation von R-Packages sieht wie folgt aus: install.packages(<package name>). Das “RODBC” Package wird entsprechend installiert: install.packages(“RODBC”). Die Dokumentation, die im Paket mitgeliefert wird, kann eine große Hilfe sein. Sie lässt sich nach der Installation mit dem Befehl RShowDoc(“RODBC”, package=”RODBC”) aufrufen. Sind diese Schritte erfolgreich abgearbeitet, lassen sich “R-Skripte” mit dem Konnektor “R-Script” direkt aus Power BI heraus ausführen.

Die geladenen Daten können nun in Power BI weiterverarbeitet werden, dabei stehen die bekannten Features (wie z.B. Filterung) zur Verfügung.

R-Visual

Power BI verfügt noch über eine weitere Integration von R, in Form eines Visuals. Das R-Visual lässt sich wie ein gewöhnliches Visual über den Katalog auswählen. Wie man das von anderen Visuals gewohnt ist, müssen auch für die R-Visuals Spalten aus bereits importierten Tabellen gewählt werden. Ein R-Script, das automatisch gestartet wird, schreibt die gewählten Daten in einen “data frame”. Dieser “data frame” kann via R-Script manipuliert und nach Belieben visualisiert werden. Die Grafiken, die R anbietet, reichen vom Boxplot, über Streudiagramme bis hin zu Plotted Maps. Mit Plotted Maps kann man unter anderem Länder und deren Bevölkerungsdichte grafisch abbilden. Inzwischen gibt es einen Preview Service, der es möglich macht, die R-Visuals im Web und in den Apps darzustellen.

Fallbeispiel – ShowTime BI

Im Folgenden wird die R-Komponente an einem Beispiel vorgestellt. Das Beispiel orientiert sich an Zeiterfassungseinträgen, die in einer MS SQL-Datenbank gespeichert sind.

R-Gateway

Zum Import der Daten kommt, wie oben beschrieben, die Library “RODBC” und ein R-Script zum Einsatz. Das Eingabefeld für das R-Script ist analog zu allen anderen Konnektoren (Abbildung 1) angeordnet. Für den Datenimport wird folgendes Script ausgeführt:

RGateway

Abbildung 3: R Power BI´, Data Source – R-Script, 2016

Dieses R-Script ist recht trivial und enthält faktisch nur ein SQL-Statement und könnte auch durch den SQL Server Connector ersetzt werden. Durch Ausführen des Skriptes werden Zeiteinträge von zwei Mitarbeitern geladen. Der Connection-String wird an ein Objekt der Library RODBC übergeben. Die Connection zur Datenbank sowie das Ausführen des SQL-Statements werden von der Funktion “sqlQuery” gesteuert. Die Funktion erwartet neben dem SQL-Statement auch ein Objekt der Klasse RODBC.

Die Komplexität des R-Scripts, ist im Beispiel recht überschaubar und kann natürlich deutlich gesteigert werden, unter anderem auch mit der “Predict”-Funktion. Mit dieser Funktion lassen sich auf Basis vorhandener Daten Regressionen erzeugen. Diese können speziell für Planungen ein gutes Werkzeug sein.

R-Visual – ggplot2

Die Daten, die über die ODBC-Verbindung geladen wurden, können nun mit Hilfe des R-Visuals grafisch dargestellt werden. Nach Auswahl des R-Visuals und der gewünschten Spalten, jeweils per Drag’n’Drop, kann man auf Basis der automatisch erzeugten “data frames”, Grafiken mit R-Scripten generieren und über die Kommandozeile ausführen.  Die Kommandozeile wird durch Selektion des R-Visuals sichtbar. Für das verwendete Skript ist das Package ggplot2 zu installieren. Dies erfolgt, analog zur Installation von “RODBC”, durch den Befehl, install.packages(“ggplot2”).

R-ScriptBoxplot

Abbildung 4: R-Visual, Kommandozeile; ggplot2, 2016

Führt man dieses Skript aus (Run, im Bild oben rechts) erhält man folgende Grafik:

RBoxplot

Abbildung 5: R-Visual, ggplot2, 2016

Farben und Beschriftungen lassen sich im R-Script nach Belieben anpassen.

In einem weiteren Beispiel werden die Zeiteinträge aller Mitarbeiter in einem Streudiagramm dargestellt. Ermöglicht wird dies durch ggplot und die Funktion geom_point(). Anders als in Beispiel 1 wird an dieser Stelle nicht auf bereits importierte Daten zugegriffen. Die Abfrage der Daten wird aus der R-Visual Kommandozeile heraus ausgeführt.

StreudiagrammSkript

Abbildung 6: R-Visual, Kommandozeile; Streudiagramm, 2016

Durch Ausführen des Skripts erhält man folgende Grafik:

RStreudiagramm2

Abbildung 7: R-Visual, angepasstes Streudiagramm, 2016

Auch für diese Darstellungen lassen sich Beschriftung und Farben je nach Wunsch über das R-Script anpassen.

Fazit

Power BI bietet grundsätzlich eine große Vielfalt, wenn es darum geht, Daten grafisch abzubilden. Durch die Erweiterung um die R-Visuals sind die Möglichkeiten Daten grafisch darzustellen vielfältig. R verfügt durch die Vielzahl von verschiedenen Paketen über sehr viele unterschiedliche Darstellungsmöglichkeiten. Alle Plots können mittels R-Script sehr individuell an die eigenen Vorstellungen angepasst werden. Schaut man sich die Entwicklung der Anzahl von R-Anwendern und die Bedeutung von Datenanalyse im Allgemeinen an, macht es durchaus Sinn, dass Microsoft R in seinen Produkten integriert. Ein weiterer Punkt, der für die R-Integration spricht, sind Predictive Analytics. Der Anwender hat die Möglichkeit, aus bestehenden Daten neue Informationen abzuleiten und Wissen zu generieren. Für Data Scientists verbessert sich durch die R-Integration, die Weitergabe und Speicherung von Analysen. Via Cloud, welche Power BI unterstützt, können Analysen geteilt und jederzeit überarbeitet werden.