Machine Learning – Die Referenz: Mit strukturierten Daten in Python arbeiten

Von Matt Harrison

Das praktische Nachschlagewerk zum Machine Learning mit strukturierten Daten
Konzentriert sich auf Themen, die für den praktizierenden Machine-Learning-Anwender interessant sind
Enthält eine große Anzahl wertvoller Codebeispiele für strukturierte Daten, die in der Praxis konkret weiterhelfen/ul>
Zeigt, wie verschiedene Bibliotheken zur Lösung praktischer Fragestellungen eingesetzt werden
Diese praktische Referenz ist eine Sammlung von Methoden, Ressourcen und Codebeispielen zur Lösung gängiger Machine-Learning-Probleme mit strukturierten Daten. Der Autor Matt Harrison hat einen wertvollen Leitfaden zusammengestellt, den Sie als zusätzliche Unterstützung während eines Machine-Learning-Kurses nutzen können oder als Nachschlagewerk, wenn Sie Ihr nächstes ML-Projekt mit Python starten.
Das Buch ist ideal für Data Scientists, Softwareentwickler und Datenanalysten, die Machine Learning praktisch anwenden. Es bietet einen Überblick über den kompletten Machine-Learning-Prozess und führt Sie durch die Klassifizierung strukturierter Daten. Sie lernen dann unter anderem Methoden zur Modellauswahl, zur Regression, zur Reduzierung der Dimensionalität und zum Clustering kennen. Die Codebeispiele sind so kompakt angelegt, dass Sie sie für Ihre eigenen Projekte verwenden und auch gut anpassen können.

• Sprache: Deutsch
• Herausgeber: O'Reilly
• Erscheinungsdatum: 28. Okt. 2020
• ISBN: 9783960104094

Buchvorschau

KAPITEL 1

Einleitung

Das vorliegende Buch ist weniger eine Bedienungsanleitung als vielmehr eine Sammlung von Notizen, Tabellen und Beispielen für maschinelles Lernen. Es entstand als zusätzliche Ressource für Schulungen des Autors und wird dort als reales Notizbuch ausgeteilt. Teilnehmer (die die physischen Eigenschaften von Materialien aus totem Baum bevorzugen) konnten ihre eigenen Notizen und Gedanken hinzufügen und hatten eine wertvollen Referenz ausgewählter Beispiele.

Wir werden Klassifikationsaufgaben mit strukturierten Daten Schritt für Schritt durchgehen. Weiterhin betrachten wir übliche Machine-Learning-Anwendungen wie die Vorhersage eines stetigen Werts (Regression), Clusterbildung sowie den Versuch der Dimensionsreduktion. Dieses Buch verzichtet darauf, Deep-Learning-Techniken zu diskutieren. Während solche Techniken für unstrukturierte Daten gut funktionieren, sind die Techniken aus dem vorliegenden Buch am ehesten für strukturierte Daten zu empfehlen.

Wir setzen voraus, dass der Leser mit Python vertraut ist. Es empfiehlt sich, zu lernen, wie man Daten mit der Bibliothek pandas (https://pandas.pydata.org) verarbeitet. Viele unserer Beispiele verwenden pandas, und es ist ein ausgezeichnetes Werkzeug für den Umgang mit strukturierten Daten. Außerdem können manche der Indizierungsoperationen verwirrend sein, wenn man sich nicht mit numpy (https://numpy.org/) auskennt. Für eine vollständige Besprechung von numpy und pandas wäre ein eigenes Buch notwendig.

Verwendete Bibliotheken

In diesem Buch werden viele Bibliotheken benutzt. Das hat Vor- und Nachteile. Einige dieser Bibliotheken können schwierig zu installieren sein oder zu Konflikten mit anderen Bibliotheksversionen führen. Sie müssen aber auch nicht alle diese Bibliotheken installieren. Nutzen Sie den Just-in-time-Ansatz und installieren Sie immer nur die Bibliotheken, die Sie gerade benötigen.

>>> import autosklearn, catboost,

category_encoders, dtreeviz, eli5, fancyimpute,

fastai, featuretools, glmnet_py, graphviz,

hdbscan, imblearn, janitor, lime, matplotlib,

missingno, mlxtend, numpy, pandas, pdpbox, phate,

pydotplus, rfpimp, scikitplot, scipy, seaborn,

shap, sklearn, statsmodels, tpot, treeinterpreter,

umap, xgbfir, xgboost, yellowbrick

>>> for lib in [

...    autosklearn,

...    catboost,

...    category_encoders,

...    dtreeviz,

...    eli5,

...    fancyimpute,

...    fastai,

...    featuretools,

...    glmnet_py,

...    graphviz,

...    hdbscan,

...    imblearn,

...    lime,

...    janitor,

...    matplotlib,

...    missingno,

...    mlxtend,

...    numpy,

...    pandas,

...    pandas_profiling,

...    pdpbox,

...    phate,

...    pydotplus,

...    rfpimp,

...    scikitplot,

...    scipy,

...    seaborn,

...    shap,

...    sklearn,

...    statsmodels,

...    tpot,

...    treeinterpreter,

...    umap,

...    xgbfir,

...    xgboost,

...    yellowbrick,

... ]:

...    try:

...        print(lib.__name__, lib.__version__)

...    except:

...        print(Missing, lib.__name__)

catboost 0.11.1

category_encoders 2.0.0

Missing dtreeviz

eli5 0.8.2

fancyimpute 0.4.2

fastai 1.0.28

featuretools 0.4.0

Missing glmnet_py

graphviz 0.10.1

hdbscan 0.8.22

imblearn 0.4.3

janitor 0.16.6

Missing lime

matplotlib 2.2.3

missingno 0.4.1

mlxtend 0.14.0

numpy 1.15.2

pandas 0.23.4

Missing pandas_profiling

pdpbox 0.2.0

phate 0.4.2

Missing pydotplus

rfpimp

scikitplot 0.3.7

scipy 1.1.0

seaborn 0.9.0

shap 0.25.2

sklearn 0.21.1

statsmodels 0.9.0

tpot 0.9.5

treeinterpreter 0.1.0

umap 0.3.8

xgboost 0.81

yellowbrick 0.9

Es gibt zwei hauptsächliche Wege, Bibliotheken in Python zu installieren. Der eine führt über pip (eine Abkürzung für Pip Installs Python), das mit Python mitgeliefert wird. Die andere Möglichkeit ist, mit Anaconda (https://anaconda.org) zu arbeiten. Wir werden beide Wege vorstellen.

Installation mit pip

Bevor wir pip benutzen, erstellen wir eine Sandbox-Umgebung, in die wir unsere Bibliotheken installieren. So etwas heißt virtuelle Umgebung, und wir nennen sie env:

$ python -m venv env

Danach aktivieren Sie die Umgebung, damit Sie Ihre Bibliotheken in die Sandbox-Umgebung installieren und nicht in die globale Python-Installation. Da sich viele dieser Bibliotheken weiterentwickeln und aktualisiert werden, ist es das Beste, die verwendeten Versionen für jedes Projekt festzuschreiben, damit Sie sicher sein können, dass Ihr Code läuft.

Folgendermaßen aktivieren Sie die virtuelle Umgebung auf Linux und Macintosh:

$ source env/bin/activate

Sie werden sehen, dass sich der Prompt verändert und nun anzeigt, dass wir die virtuelle Umgebung verwenden:

(env) $ which python

env/bin/python

Auf Windows müssen Sie die Umgebung mit diesem Befehl aktivieren:

C:> env\Scripts\activate.bat

Wiederum werden Sie feststellen, dass der Prompt angepasst wird, um anzuzeigen, dass wir mit der virtuellen Umgebung arbeiten:

(env) C:> where python

env\Scripts\python.exe

Auf allen Plattformen können Sie Pakete mit pip installieren. Um pandas zu installieren, geben Sie ein:

(env) $ pip install pandas

In manchen Fällen heißt das Paket anders als die Bibliothek. So können Sie nach Paketen suchen:

(env) $ pip search libraryname

Sobald Sie Ihre Pakete installiert haben, können Sie mithilfe von pip eine Datei mit allen verwendeten Paketversionen anlegen:

(env) $ pip freeze > requirements.txt

Mit der Datei requirements.txt können Sie alle Pakete ganz einfach in eine neue virtuelle Umgebung installieren:

(other_env) $ pip install -r requirements.txt

Installation mit conda

Das Werkzeug conda gehört zu Anaconda. Wir können damit Umgebungen anlegen und Pakete installieren.

Um eine Umgebung namens env zu erzeugen, führen Sie Folgendes aus:

$ conda create --name env python=3.6

Aktivieren Sie diese Umgebung:

$ conda activate env

Damit verändert sich der Prompt sowohl auf Unix- als auch auf Windows-Systemen. Sie können nun nach Paketen suchen:

(env) $ conda search libraryname

So installieren Sie ein Paket wie pandas:

(env) $ conda install pandas

Legen Sie eine Datei mit den benötigten Paketen folgendermaßen an:

(env) $ conda env export > environment.yml

Installieren Sie diese Pakete in einer neuen Umgebung:

(other_env) $ conda create -f environment.yml

KAPITEL 2

Der Vorgang des maschinellen Lernens: Überblick

Der branchenübergreifende Standardprozess für das Data-Mining (engl. Cross-Industry Standard Process for Data Mining, CRISP-DM) ist ein Ablaufplan für Data-Mining. Er besteht aus mehreren Schritten, die zu immer weiteren Verbesserungen führen:

Verständnis der zu lösenden Aufgabe

Verständnis der Daten

Datenaufbereitung

Modellierung

Auswertung

Einsatz

Abbildung 2-1 zeigt meinen Arbeitsablauf für die Erstellung eines Vorhersagemodells, das auf der Methode CRISP-DM aufbaut. Das nächste Kapitel wird diese grundlegenden Schritte durchgehen.

Abbildung 2-1: Gewöhnlicher Arbeitsablauf beim maschinellen Lernen

KAPITEL 3

Klassifikation Schritt für Schritt: der Titanic-Datensatz

In diesem Kapitel arbeiten wir Schritt für Schritt eine gewöhnliche Klassifikationsaufgabe anhand des Titanic-Datensatzes (https://oreil.ly/PjceO) durch. Spätere Kapitel werden dann die immer wiederkehrenden Schritte der Analyse im Einzelnen betrachten und weiter ausführen.

Vorschlag für das Projektlayout

Ein ausgezeichnetes Werkzeug für die explorative Datenanalyse ist Jupyter (https://jupyter.org). Jupyter ist eine quelloffene Notebook-Umgebung, die Python und andere Sprachen unterstützt. Sie können damit Zellen mit Code oder Mark-down-Inhalt anlegen.

Ich verwende Jupyter gern in zwei unterschiedlichen Modi. Der eine empfiehlt sich für explorative Datenanalyse und um Dinge schnell auszuprobieren. Der andere eignet sich eher für einen abzugebenden Bericht, den ich mithilfe von Mark-down-Zellen formatiere und in den ich Codezellen einfüge, um wichtige Aussagen oder Erkenntnisse zu veranschaulichen. Rechnen Sie aber damit, dass Sie auch in Notebooks hin und wieder Code refaktorieren und Techniken der Softwareentwicklung anwenden müssen, also auf globale Variablen verzichten, Funktionen und Klassen benutzen usw.

Das Datenanalysepaket cookiecutter (https://oreil.ly/86jL3) bietet ein Layout für eine Analyse an, die leicht nachzuvollziehen ist und die Wiederverwendung von Code erlaubt.

Importe

Dieses Beispiel verwendet im Wesentlichen pandas (http://pandas.pydata.org/), scikit-learn (https://scikit-learn.org/) und Yellowbrick (http://www.scikit-yb.org/). Die Bibliothek pandas macht es uns leicht, Daten umzuformen, scikit-learn bietet eine großartige Vorhersagemodellierung, und Yellowbrick ist eine Visualisierungsbibliothek für die Auswertung von Modellen:

>>> import matplotlib.pyplot as plt

>>> import pandas as pd

>>> from sklearn import (

...    ensemble,

...    preprocessing,

...    tree,

... )

>>> from sklearn.metrics import (

...    auc,

...    confusion_matrix,

...    roc_auc_score,

...    roc_curve,

... )

>>> from sklearn.model_selection import (

...    train_test_split,

...    StratifiedKFold,

... )

>>> from yellowbrick.classifier import (

...    ConfusionMatrix,

...    ROCAUC,

... )

>>> from yellowbrick.model_selection import (

...    LearningCurve,

... )

Eine Frage stellen

In diesem Beispiel wollen wir ein Vorhersagemodell erstellen, das eine Frage beantwortet. Es wird eine Person anhand ihrer Merkmale und Reisedaten danach klassifizieren, ob sie voraussichtlich das Schiffsunglück der Titanic überlebt. Das ist ein Spielbeispiel, aber es dient als Lehrstück, an dem sich viele Schritte der Modellierung zeigen lassen. Unser Modell sollte Passagierinformationen verarbeiten und vorhersagen, ob dieser Passagier auf der Titanic überleben würde.

Es handelt sich hierbei um eine Klassifikationsfrage, da wir einen Wert für das Überleben vorhersagen; jede Person hat entweder überlebt oder ist gestorben.

Begriffe und Bezeichnungen für die Daten

Normalerweise trainieren wir ein Modell mit einer Matrix von Daten. (Ich bevorzuge dafür die DataFrames von pandas, weil Spaltennamen etwas sehr Angenehmes sind, aber numpy-Arrays funktionieren auch.)

Für überwachtes Lernen wie etwa Regression oder Klassifikation wollen wir eine Funktion finden, die Merkmale in Markierungen verwandelt. Als algebraische Funktion geschrieben, würde das so aussehen:

y = f(X)

X ist eine Matrix. Jede Zeile steht für einen Datenpunkt: die Angaben zu einer Person. Jede Spalte in X ist ein Merkmal. Die Ausgabe unserer Funktion, y, ist ein Vektor, der Markierungen (für Klassifikation) oder Werte (für Regression) enthält (siehe Abbildung 3-1).

Abbildung 3-1: Anordnung der strukturierten Daten

Das sind Standardbezeichnungen für die Daten und die Ausgaben. Akademische Veröffentlichungen und selbst die Dokumentation von Bibliotheken folgen dieser Konvention. Auch in Python verwenden wir den Variablennamen X für die Matrix der Datenpunkte, obwohl großgeschriebene Variablen die üblichen Namenskonventionen (PEP 8) verletzen. Aber keine Sorge, das machen alle so, und wenn Sie Ihre Variable x nennen, würde man Sie komisch anschauen. Die Variable y enthält die Markierungen oder Zielgrößen.

Tabelle 3-1 zeigt einen einfachen Datensatz mit zwei Datenpunkten und jeweils drei Merkmalen.

Tabelle 3-1: Datenpunkte (Zeilen) und Merkmale (Spalten)

Daten sammeln

Wir werden eine Excel-Datei mit dem Titanic-Datensatz laden. (Dazu müssen Sie pandas und xlrd installiert haben.¹) Sie hat viele Spalten, darunter eine mit dem Merkmal »survival«, das besagt, wie es der Person ergangen ist:

>>> url = (

...    http://biostat.mc.vanderbilt.edu/

...    wiki/pub/Main/DataSets/titanic3.xls

... )

>>> df = pd.read_excel(url)

>>> orig_df = df

Folgende Spalten sind im Datensatz enthalten:

pclass – Passagierklasse (1 = erste, 2 = zweite, 3 = dritte)

survival – Überleben (0 = Nein, 1 = Ja)

name – Name

sex – Geschlecht

age – Alter

sibsp – Anzahl der Geschwister bzw. Partner an Bord

parch – Anzahl der Eltern bzw. Kinder an Bord

ticket – Fahrscheinnummer

fare – Fahrpreis

cabin – Kabine

embarked – Zustiegsort (C = Cherbourg, Q = Queenstown, S = Southampton)

boat – Rettungsboot

body – Identifikationsnummer der Leiche

home.dest – Wohnort bzw. Reiseziel

Pandas kann diese Tabelle lesen und für uns in einen DataFrame umwandeln. Wir werden die Daten stichprobenweise prüfen und darauf achten, dass sie sich für die Untersuchung eignen.

Daten säubern

Nachdem wir die Daten haben, müssen wir sie so formatieren, dass wir damit ein Modell erstellen können. Die meisten scikit-learn-Modelle verlangen numerische Merkmale (ganze oder Fließkommazahlen). Viele Modelle versagen, wenn ihnen fehlende Werte (NaN in pandas oder numpy) übergeben werden. Einige Modelle liefern bessere Ergebnisse, wenn die Daten standardisiert (also auf einen Mittelwert von null und eine Standardabweichung von eins gebracht) wurden. Dafür werden wir pandas oder scikit-learn nutzen. Obendrein enthält der Titanic-Datensatz aber auch verräterische Merkmale.

Verräterische Merkmale sind Variablen, die Informationen über die Zukunft oder die Zielgröße enthalten. Daten über die Zielgröße sind nichts Schlechtes, und häufig liegen sie zur Erstellungszeit eines Modells vor. Sind solche Daten jedoch nicht verfügbar, wenn wir eine Vorhersage für einen neuen Datenpunkt treffen, sollten wir sie aus dem Modell entfernen, weil sie Informationen aus der Zukunft durchsickern lassen.

Daten zu säubern, kann eine Weile dauern. Es ist hilfreich, sich von einem Fachexperten Rat zum Umgang mit Ausreißern oder fehlenden Daten einzuholen.

>>> df.dtypes

pclass        int64

survived      int64

name          object

sex          object

age          float64

sibsp          int64

parch          int64

ticket        object

fare        float64

cabin        object

embarked      object

boat          object

body        float64

home.dest    object

dtype: object

Normalerweise begegnen uns die Datentypen int64,