H2O - Kurzanleitung

Wurden Sie jemals gebeten, ein Modell für maschinelles Lernen in einer riesigen Datenbank zu entwickeln? In der Regel stellt Ihnen der Kunde die Datenbank zur Verfügung und fordert Sie auf, bestimmte Vorhersagen zu treffen, z. B. wer die potenziellen Käufer sein werden. Wenn betrügerische Fälle usw. frühzeitig erkannt werden können. Um diese Fragen zu beantworten, besteht Ihre Aufgabe darin, einen Algorithmus für maschinelles Lernen zu entwickeln, der eine Antwort auf die Kundenanfrage liefert. Die Entwicklung eines Algorithmus für maschinelles Lernen von Grund auf ist keine leichte Aufgabe. Warum sollten Sie dies tun, wenn auf dem Markt mehrere gebrauchsfertige Bibliotheken für maschinelles Lernen verfügbar sind?

Heutzutage möchten Sie diese Bibliotheken lieber verwenden, einen gut getesteten Algorithmus aus diesen Bibliotheken anwenden und die Leistung überprüfen. Wenn die Leistung nicht innerhalb akzeptabler Grenzen liegt, würden Sie versuchen, entweder den aktuellen Algorithmus zu optimieren oder einen ganz anderen zu versuchen.

Ebenso können Sie mehrere Algorithmen für denselben Datensatz ausprobieren und dann den besten auswählen, der die Anforderungen des Kunden zufriedenstellend erfüllt. Hier kommt H2O zu Ihrer Rettung. Es ist ein Open-Source-Framework für maschinelles Lernen mit vollständig getesteten Implementierungen mehrerer weit verbreiteter ML-Algorithmen. Sie müssen nur den Algorithmus aus seinem riesigen Repository abrufen und auf Ihren Datensatz anwenden. Es enthält die am häufigsten verwendeten statistischen und ML-Algorithmen.

Um hier einige zu nennen, umfasst es gradientenverstärkte Maschinen (GBM), ein verallgemeinertes lineares Modell (GLM), tiefes Lernen und vieles mehr. Es unterstützt nicht nur die AutoML-Funktionalität, mit der die Leistung verschiedener Algorithmen in Ihrem Dataset bewertet wird, wodurch sich Ihr Aufwand für die Suche nach dem Modell mit der besten Leistung verringert. H2O wird weltweit von mehr als 18000 Organisationen verwendet und ist für eine einfache Entwicklung gut mit R und Python verbunden. Es ist eine In-Memory-Plattform, die hervorragende Leistung bietet.

In diesem Tutorial lernen Sie zunächst, wie Sie das H2O mit Python- und R-Optionen auf Ihrem Computer installieren. Wir werden verstehen, wie dies in der Befehlszeile verwendet wird, damit Sie die Funktionsweise verstehen. Wenn Sie ein Python-Liebhaber sind, können Sie Jupyter oder eine andere IDE Ihrer Wahl für die Entwicklung von H2O-Anwendungen verwenden. Wenn Sie R bevorzugen, können Sie RStudio für die Entwicklung verwenden.

In diesem Tutorial betrachten wir ein Beispiel, um zu verstehen, wie man mit H2O arbeitet. Wir werden auch lernen, wie Sie den Algorithmus in Ihrem Programmcode ändern und seine Leistung mit der vorherigen vergleichen. Das H2O bietet auch ein webbasiertes Tool zum Testen der verschiedenen Algorithmen in Ihrem Datensatz. Dies nennt man Flow.

Das Tutorial führt Sie in die Verwendung von Flow ein. Daneben werden wir die Verwendung von AutoML diskutieren, mit der der Algorithmus mit der besten Leistung für Ihren Datensatz ermittelt wird. Bist du nicht aufgeregt, H2O zu lernen? Weiter lesen!

H2O kann mit fünf verschiedenen Optionen konfiguriert und verwendet werden, wie unten aufgeführt -

In Python installieren
In R installieren
Webbasierte Flow-GUI
Hadoop
Anaconda Cloud

In unseren folgenden Abschnitten finden Sie Anweisungen zur Installation von H2O basierend auf den verfügbaren Optionen. Sie werden wahrscheinlich eine der Optionen verwenden.

In Python installieren

Um H2O mit Python auszuführen, sind für die Installation mehrere Abhängigkeiten erforderlich. Beginnen wir also mit der Installation der Mindestabhängigkeit für die Ausführung von H2O.

Abhängigkeiten installieren

Führen Sie den folgenden pip-Befehl aus, um eine Abhängigkeit zu installieren:

$ pip install requests

Öffnen Sie Ihr Konsolenfenster und geben Sie den obigen Befehl ein, um das Anforderungspaket zu installieren. Der folgende Screenshot zeigt die Ausführung des obigen Befehls auf unserem Mac-Computer -

Nach der Installation der Anforderungen müssen Sie drei weitere Pakete installieren, wie unten gezeigt -

$ pip install tabulate
$ pip install "colorama >= 0.3.8"
$ pip install future

Die aktuellste Liste der Abhängigkeiten finden Sie auf der H2O GitHub-Seite. Zum Zeitpunkt dieses Schreibens sind die folgenden Abhängigkeiten auf der Seite aufgeführt.

python 2. H2O — Installation
pip >= 9.0.1
setuptools
colorama >= 0.3.7
future >= 0.15.2

Ältere Versionen entfernen

Nach der Installation der oben genannten Abhängigkeiten müssen Sie alle vorhandenen H2O-Installationen entfernen. Führen Sie dazu den folgenden Befehl aus:

$ pip uninstall h2o

Neueste Version installieren

Lassen Sie uns nun die neueste Version von H2O mit dem folgenden Befehl installieren:

$ pip install -f http://h2o-release.s3.amazonaws.com/h2o/latest_stable_Py.html h2o

Nach erfolgreicher Installation sollte die folgende Meldung auf dem Bildschirm angezeigt werden:

Installing collected packages: h2o
Successfully installed h2o-3.26.0.1

Installation testen

Um die Installation zu testen, führen wir eine der Beispielanwendungen aus, die in der H2O-Installation bereitgestellt werden. Starten Sie zuerst die Python-Eingabeaufforderung, indem Sie den folgenden Befehl eingeben:

$ Python3

Geben Sie nach dem Start des Python-Interpreters die folgende Python-Anweisung an der Python-Eingabeaufforderung ein:

>>>import h2o

Der obige Befehl importiert das H2O-Paket in Ihr Programm. Initialisieren Sie als Nächstes das H2O-System mit dem folgenden Befehl:

>>>h2o.init()

Ihr Bildschirm zeigt die Clusterinformationen an und sollte zu diesem Zeitpunkt wie folgt aussehen:

Jetzt können Sie den Beispielcode ausführen. Geben Sie den folgenden Befehl an der Python-Eingabeaufforderung ein und führen Sie ihn aus.

>>>h2o.demo("glm")

Die Demo besteht aus einem Python-Notizbuch mit einer Reihe von Befehlen. Nachdem Sie jeden Befehl ausgeführt haben, wird seine Ausgabe sofort auf dem Bildschirm angezeigt und Sie werden aufgefordert, die Taste zu drücken, um mit dem nächsten Schritt fortzufahren. Der teilweise Screenshot zum Ausführen der letzten Anweisung im Notizbuch wird hier angezeigt -

Zu diesem Zeitpunkt ist Ihre Python-Installation abgeschlossen und Sie können Ihre eigenen Experimente durchführen.

In R installieren

Die Installation von H2O für die R-Entwicklung ist der Installation für Python sehr ähnlich, außer dass Sie die R-Eingabeaufforderung für die Installation verwenden würden.

R-Konsole starten

Starten Sie die R-Konsole, indem Sie auf das R-Anwendungssymbol auf Ihrem Computer klicken. Der Konsolenbildschirm wird wie im folgenden Screenshot dargestellt angezeigt:

Ihre H2O-Installation würde an der obigen R-Eingabeaufforderung erfolgen. Wenn Sie RStudio bevorzugen, geben Sie die Befehle in das Unterfenster der R-Konsole ein.

Ältere Versionen entfernen

Entfernen Sie zunächst ältere Versionen mit dem folgenden Befehl an der Eingabeaufforderung R:

> if ("package:h2o" %in% search()) { detach("package:h2o", unload=TRUE) }
> if ("h2o" %in% rownames(installed.packages())) { remove.packages("h2o") }

Abhängigkeiten herunterladen

Laden Sie die Abhängigkeiten für H2O mit dem folgenden Code herunter:

> pkgs <- c("RCurl","jsonlite")
for (pkg in pkgs) {
   if (! (pkg %in% rownames(installed.packages()))) { install.packages(pkg) }
}

H2O installieren

Installieren Sie H2O, indem Sie den folgenden Befehl an der Eingabeaufforderung R eingeben:

> install.packages("h2o", type = "source", repos = (c("http://h2o-release.s3.amazonaws.com/h2o/latest_stable_R")))

Der folgende Screenshot zeigt die erwartete Ausgabe -

Es gibt eine andere Möglichkeit, H2O in R zu installieren.

Installieren Sie in R von CRAN

Verwenden Sie den folgenden Befehl an der R-Eingabeaufforderung, um R von CRAN zu installieren:

> install.packages("h2o")

Sie werden aufgefordert, den Spiegel auszuwählen -

--- Please select a CRAN mirror for use in this session ---

Auf Ihrem Bildschirm wird ein Dialogfeld mit der Liste der Spiegelseiten angezeigt. Wählen Sie den nächstgelegenen Ort oder den Spiegel Ihrer Wahl.

Installation testen

Geben Sie an der Eingabeaufforderung R den folgenden Code ein und führen Sie ihn aus:

> library(h2o)
> localH2O = h2o.init()
> demo(h2o.kmeans)

Die erzeugte Ausgabe ist wie im folgenden Screenshot gezeigt -

Ihre H2O-Installation in R ist jetzt abgeschlossen.

Installieren von Web GUI Flow

Um GUI Flow zu installieren, laden Sie die Installationsdatei von der H20-Site herunter. Entpacken Sie die heruntergeladene Datei in Ihren bevorzugten Ordner. Beachten Sie das Vorhandensein der Datei h2o.jar in der Installation. Führen Sie diese Datei in einem Befehlsfenster mit dem folgenden Befehl aus:

$ java -jar h2o.jar

Nach einer Weile wird Folgendes in Ihrem Konsolenfenster angezeigt.

07-24 16:06:37.304 192.168.1.18:54321 3294 main INFO: H2O started in 7725ms
07-24 16:06:37.304 192.168.1.18:54321 3294 main INFO:
07-24 16:06:37.305 192.168.1.18:54321 3294 main INFO: Open H2O Flow in your web browser: http://192.168.1.18:54321
07-24 16:06:37.305 192.168.1.18:54321 3294 main INFO:

Öffnen Sie die angegebene URL, um den Flow zu starten http://localhost:54321in Ihrem Browser. Der folgende Bildschirm wird angezeigt -

Zu diesem Zeitpunkt ist Ihre Flow-Installation abgeschlossen.

Auf Hadoop / Anaconda Cloud installieren

Wenn Sie kein erfahrener Entwickler sind, würden Sie nicht daran denken, H2O für Big Data zu verwenden. Hier genügt es zu sagen, dass H2O-Modelle auf riesigen Datenbanken mit mehreren Terabyte effizient ausgeführt werden. Wenn sich Ihre Daten in Ihrer Hadoop-Installation oder in der Cloud befinden, befolgen Sie die auf der H2O-Site angegebenen Schritte, um sie für Ihre jeweilige Datenbank zu installieren.

Nachdem Sie H2O erfolgreich auf Ihrer Maschine installiert und getestet haben, sind Sie bereit für eine echte Entwicklung. Zuerst sehen wir die Entwicklung an einer Eingabeaufforderung. In unseren folgenden Lektionen lernen wir, wie man Modelltests in H2O Flow durchführt.

Entwickeln in der Eingabeaufforderung

Betrachten wir nun die Verwendung von H2O zur Klassifizierung von Pflanzen des bekannten Iris-Datensatzes, der für die Entwicklung von Anwendungen für maschinelles Lernen frei verfügbar ist.

Starten Sie den Python-Interpreter, indem Sie den folgenden Befehl in Ihr Shell-Fenster eingeben:

$ Python3

Dies startet den Python-Interpreter. Importieren Sie die H2O-Plattform mit dem folgenden Befehl:

>>> import h2o

Wir werden den Random Forest-Algorithmus zur Klassifizierung verwenden. Dies ist im H2ORandomForestEstimator-Paket enthalten. Wir importieren dieses Paket mit der import-Anweisung wie folgt:

>>> from h2o.estimators import H2ORandomForestEstimator

Wir initialisieren die H2o-Umgebung, indem wir ihre init-Methode aufrufen.

>>> h2o.init()

Nach erfolgreicher Initialisierung sollte auf der Konsole die folgende Meldung zusammen mit den Clusterinformationen angezeigt werden.

Checking whether there is an H2O instance running at http://localhost:54321 . connected.

Jetzt importieren wir die Irisdaten mit der Methode import_file in H2O.

>>> data = h2o.import_file('iris.csv')

Der Fortschritt wird wie im folgenden Screenshot gezeigt angezeigt -

Nachdem die Datei in den Speicher geladen wurde, können Sie dies überprüfen, indem Sie die ersten 10 Zeilen der geladenen Tabelle anzeigen. Sie verwenden diehead Methode dazu -

>>> data.head()

Sie sehen die folgende Ausgabe in Tabellenform.

In der Tabelle werden auch die Spaltennamen angezeigt. Wir werden die ersten vier Spalten als Merkmale für unseren ML-Algorithmus und die letzte Spaltenklasse als vorhergesagte Ausgabe verwenden. Wir spezifizieren dies im Aufruf unseres ML-Algorithmus, indem wir zuerst die folgenden zwei Variablen erstellen.

>>> features = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
>>> output = 'class'

Als Nächstes teilen wir die Daten in Training und Test auf, indem wir die split_frame-Methode aufrufen.

>>> train, test = data.split_frame(ratios = [0.8])

Die Daten werden im Verhältnis 80:20 aufgeteilt. Wir verwenden 80% Daten für Schulungen und 20% für Tests.

Jetzt laden wir das integrierte Random Forest-Modell in das System.

>>> model = H2ORandomForestEstimator(ntrees = 50, max_depth = 20, nfolds = 10)

Im obigen Aufruf setzen wir die Anzahl der Bäume auf 50, die maximale Tiefe für den Baum auf 20 und die Anzahl der Falten für die Kreuzvalidierung auf 10. Wir müssen nun das Modell trainieren. Wir tun dies, indem wir die Zugmethode wie folgt aufrufen:

>>> model.train(x = features, y = output, training_frame = train)

Die Zugmethode empfängt die Features und die Ausgabe, die wir zuvor als erste beiden Parameter erstellt haben. Der Trainingsdatensatz ist auf Training eingestellt, was 80% unseres vollständigen Datensatzes entspricht. Während des Trainings sehen Sie den Fortschritt wie hier gezeigt -

Jetzt, da der Modellierungsprozess abgeschlossen ist, ist es Zeit, das Modell zu testen. Dazu rufen wir die Methode model_performance für das trainierte Modellobjekt auf.

>>> performance = model.model_performance(test_data=test)

Im obigen Methodenaufruf haben wir Testdaten als unseren Parameter gesendet.

Es ist jetzt Zeit, die Ausgabe zu sehen, die die Leistung unseres Modells darstellt. Sie tun dies, indem Sie einfach die Leistung drucken.

>>> print (performance)

Dies gibt Ihnen die folgende Ausgabe -

Die Ausgabe zeigt den mittleren quadratischen Fehler (MSE), den mittleren quadratischen Fehler (RMSE), LogLoss und sogar die Verwirrungsmatrix.

Laufen in Jupyter

Wir haben die Ausführung des Befehls gesehen und auch den Zweck jeder Codezeile verstanden. Sie können den gesamten Code in einer Jupyter-Umgebung ausführen, entweder Zeile für Zeile oder das gesamte Programm gleichzeitig. Die vollständige Auflistung finden Sie hier -

import h2o
from h2o.estimators import H2ORandomForestEstimator
h2o.init()
data = h2o.import_file('iris.csv')
features = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
output = 'class'
train, test = data.split_frame(ratios=[0.8])
model = H2ORandomForestEstimator(ntrees = 50, max_depth = 20, nfolds = 10)
model.train(x = features, y = output, training_frame = train)
performance = model.model_performance(test_data=test)
print (performance)

Führen Sie den Code aus und beobachten Sie die Ausgabe. Sie können jetzt erkennen, wie einfach es ist, einen Random Forest-Algorithmus auf Ihren Datensatz anzuwenden und zu testen. Die Leistung von H20 geht weit über diese Fähigkeit hinaus. Was ist, wenn Sie ein anderes Modell mit demselben Datensatz ausprobieren möchten, um festzustellen, ob Sie eine bessere Leistung erzielen können? Dies wird in unserem nachfolgenden Abschnitt erläutert.

Anwenden eines anderen Algorithmus

Jetzt lernen wir, wie Sie einen Gradientenverstärkungsalgorithmus auf unseren früheren Datensatz anwenden, um zu sehen, wie er funktioniert. In der obigen vollständigen Liste müssen Sie nur zwei geringfügige Änderungen vornehmen, wie im folgenden Code hervorgehoben -

import h2o 
from h2o.estimators import H2OGradientBoostingEstimator
h2o.init()
data = h2o.import_file('iris.csv')
features = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
output = 'class'
train, test = data.split_frame(ratios = [0.8]) 
model = H2OGradientBoostingEstimator
(ntrees = 50, max_depth = 20, nfolds = 10)
model.train(x = features, y = output, training_frame = train)
performance = model.model_performance(test_data = test)
print (performance)

Führen Sie den Code aus und Sie erhalten die folgende Ausgabe:

Vergleichen Sie einfach die Ergebnisse wie MSE, RMSE, Confusion Matrix usw. mit der vorherigen Ausgabe und entscheiden Sie, welche für die Produktionsbereitstellung verwendet werden soll. Tatsächlich können Sie verschiedene Algorithmen anwenden, um den besten zu finden, der Ihrem Zweck entspricht.

In der letzten Lektion haben Sie gelernt, H2O-basierte ML-Modelle mithilfe der Befehlszeilenschnittstelle zu erstellen. H2O Flow erfüllt den gleichen Zweck, jedoch mit einer webbasierten Oberfläche.

In den folgenden Lektionen werde ich Ihnen zeigen, wie Sie H2O Flow starten und eine Beispielanwendung ausführen.

Starten des H2O-Flusses

Die zuvor heruntergeladene H2O-Installation enthält die Datei h2o.jar. Um H2O Flow zu starten, führen Sie dieses Glas zuerst an der Eingabeaufforderung aus -

$ java -jar h2o.jar

Wenn das JAR erfolgreich ausgeführt wird, wird auf der Konsole die folgende Meldung angezeigt:

Open H2O Flow in your web browser: http://192.168.1.10:54321

Öffnen Sie nun den Browser Ihrer Wahl und geben Sie die obige URL ein. Sie sehen den webbasierten H2O-Desktop wie hier gezeigt -

Dies ist im Grunde ein Notebook ähnlich Colab oder Jupyter. Ich werde Ihnen zeigen, wie Sie eine Beispielanwendung in dieses Notizbuch laden und ausführen, während ich die verschiedenen Funktionen in Flow erläutere. Klicken Sie im obigen Bildschirm auf den Link Beispielbeispiele anzeigen, um die Liste der bereitgestellten Beispiele anzuzeigen.

Ich werde das Beispiel des Airlines Delay Flow anhand des Beispiels beschreiben.

Klicken Sie in der Liste der Beispiele auf den Link Airlines Delay Flow (siehe Abbildung unten).

Nach der Bestätigung wird das neue Notebook geladen.

Alle Ausgaben löschen

Bevor wir die Code-Anweisungen im Notizbuch erläutern, lassen Sie uns alle Ausgaben löschen und das Notizbuch dann schrittweise ausführen. Um alle Ausgänge zu löschen, wählen Sie die folgende Menüoption:

Flow / Clear All Cell Contents

Dies wird im folgenden Screenshot gezeigt -

Sobald alle Ausgaben gelöscht sind, werden wir jede Zelle im Notizbuch einzeln ausführen und ihre Ausgabe untersuchen.

Erste Zelle ausführen

Klicken Sie auf die erste Zelle. Links erscheint eine rote Flagge, die anzeigt, dass die Zelle ausgewählt ist. Dies ist wie im folgenden Screenshot gezeigt -

Der Inhalt dieser Zelle ist nur der in MarkDown (MD) geschriebene Programmkommentar. Der Inhalt beschreibt, was die geladene Anwendung tut. Um die Zelle auszuführen, klicken Sie auf das Symbol Ausführen (siehe Abbildung unten).

Unter der Zelle wird keine Ausgabe angezeigt, da die aktuelle Zelle keinen ausführbaren Code enthält. Der Cursor bewegt sich nun automatisch zur nächsten Zelle, die zur Ausführung bereit ist.

Daten importieren

Die nächste Zelle enthält die folgende Python-Anweisung:

importFiles ["https://s3.amazonaws.com/h2o-airlines-unpacked/allyears2k.csv"]

Die Anweisung importiert die Datei allyears2k.csv von Amazon AWS in das System. Wenn Sie die Zelle ausführen, wird die Datei importiert und Sie erhalten die folgende Ausgabe.

Einrichten des Datenparsers

Jetzt müssen wir die Daten analysieren und für unseren ML-Algorithmus geeignet machen. Dies erfolgt mit dem folgenden Befehl:

setupParse paths: [ "https://s3.amazonaws.com/h2o-airlines-unpacked/allyears2k.csv" ]

Nach Ausführung der obigen Anweisung wird ein Setup-Konfigurationsdialog angezeigt. Im Dialogfeld können Sie verschiedene Einstellungen zum Parsen der Datei vornehmen. Dies ist wie im folgenden Screenshot gezeigt -

In diesem Dialogfeld können Sie den gewünschten Parser aus der angegebenen Dropdown-Liste auswählen und andere Parameter wie das Feldtrennzeichen usw. festlegen.

Daten analysieren

Die nächste Anweisung, die die Datendatei mithilfe der obigen Konfiguration analysiert, ist lang und wie hier gezeigt -

parseFiles
paths: ["https://s3.amazonaws.com/h2o-airlines-unpacked/allyears2k.csv"]
destination_frame: "allyears2k.hex"
parse_type: "CSV"
separator: 44
number_columns: 31
single_quotes: false
column_names: ["Year","Month","DayofMonth","DayOfWeek","DepTime","CRSDepTime",
   "ArrTime","CRSArrTime","UniqueCarrier","FlightNum","TailNum",
   "ActualElapsedTime","CRSElapsedTime","AirTime","ArrDelay","DepDelay",
   "Origin","Dest","Distance","TaxiIn","TaxiOut","Cancelled","CancellationCode",
   "Diverted","CarrierDelay","WeatherDelay","NASDelay","SecurityDelay",
   "LateAircraftDelay","IsArrDelayed","IsDepDelayed"]
column_types: ["Enum","Enum","Enum","Enum","Numeric","Numeric","Numeric"
   ,"Numeric","Enum","Enum","Enum","Numeric","Numeric","Numeric","Numeric",
   "Numeric","Enum","Enum","Numeric","Numeric","Numeric","Enum","Enum",
   "Numeric","Numeric","Numeric","Numeric","Numeric","Numeric","Enum","Enum"]
delete_on_done: true
check_header: 1
chunk_size: 4194304

Beachten Sie, dass die Parameter, die Sie im Konfigurationsfeld eingerichtet haben, im obigen Code aufgeführt sind. Führen Sie nun diese Zelle aus. Nach einer Weile ist die Analyse abgeschlossen und Sie sehen die folgende Ausgabe:

Untersuchen des Datenrahmens

Nach der Verarbeitung wird ein Datenrahmen generiert, der mit der folgenden Anweisung überprüft werden kann:

getFrameSummary "allyears2k.hex"

Nach Ausführung der obigen Anweisung wird die folgende Ausgabe angezeigt:

Jetzt können Ihre Daten in einen Algorithmus für maschinelles Lernen eingespeist werden.

Die nächste Anweisung ist ein Programmkommentar, der besagt, dass wir das Regressionsmodell verwenden und die voreingestellte Regularisierung und die Lambda-Werte angeben.

Modell erstellen

Als nächstes kommt die wichtigste Aussage, die das Modell selbst erstellt. Dies wird in der folgenden Anweisung angegeben -

buildModel 'glm', {
   "model_id":"glm_model","training_frame":"allyears2k.hex",
   "ignored_columns":[
      "DayofMonth","DepTime","CRSDepTime","ArrTime","CRSArrTime","TailNum",
      "ActualElapsedTime","CRSElapsedTime","AirTime","ArrDelay","DepDelay",
      "TaxiIn","TaxiOut","Cancelled","CancellationCode","Diverted","CarrierDelay",
      "WeatherDelay","NASDelay","SecurityDelay","LateAircraftDelay","IsArrDelayed"],
   "ignore_const_cols":true,"response_column":"IsDepDelayed","family":"binomial",
   "solver":"IRLSM","alpha":[0.5],"lambda":[0.00001],"lambda_search":false,
   "standardize":true,"non_negative":false,"score_each_iteration":false,
   "max_iterations":-1,"link":"family_default","intercept":true,
   "objective_epsilon":0.00001,"beta_epsilon":0.0001,"gradient_epsilon":0.0001,
   "prior":-1,"max_active_predictors":-1
}

Wir verwenden glm, eine Suite für verallgemeinerte lineare Modelle, deren Familientyp auf Binomial eingestellt ist. Sie können diese in der obigen Anweisung hervorgehoben sehen. In unserem Fall ist die erwartete Ausgabe binär und deshalb verwenden wir den Binomialtyp. Sie können die anderen Parameter selbst untersuchen. Schauen Sie sich zum Beispiel Alpha und Lambda an, die wir zuvor angegeben hatten. In der Dokumentation zum GLM-Modell finden Sie Erläuterungen zu allen Parametern.

Führen Sie nun diese Anweisung aus. Bei der Ausführung wird die folgende Ausgabe generiert:

Natürlich würde die Ausführungszeit auf Ihrem Computer unterschiedlich sein. Nun kommt der interessanteste Teil dieses Beispielcodes.

Ausgabe untersuchen

Wir geben einfach das Modell aus, das wir mit der folgenden Anweisung erstellt haben:

getModel "glm_model"

Beachten Sie, dass glm_model die Modell-ID ist, die wir beim Erstellen des Modells in der vorherigen Anweisung als model_id-Parameter angegeben haben. Dies gibt uns eine riesige Ausgabe, die die Ergebnisse mit verschiedenen Parametern detailliert. Eine Teilausgabe des Berichts ist im folgenden Screenshot dargestellt -

Wie Sie in der Ausgabe sehen können, ist dies das Ergebnis der Ausführung des Algorithmus für die verallgemeinerte lineare Modellierung in Ihrem Dataset.

Direkt über der SCORING HISTORY sehen Sie das MODEL PARAMETERS-Tag, erweitern es und sehen die Liste aller Parameter, die beim Erstellen des Modells verwendet werden. Dies ist im folgenden Screenshot dargestellt.

Ebenso bietet jedes Tag eine detaillierte Ausgabe eines bestimmten Typs. Erweitern Sie die verschiedenen Tags selbst, um die Ergebnisse verschiedener Arten zu untersuchen.

Ein anderes Modell bauen

Als nächstes werden wir ein Deep Learning-Modell auf unserem Datenrahmen erstellen. Die nächste Anweisung im Beispielcode ist nur ein Programmkommentar. Die folgende Anweisung ist eigentlich ein Modellbildungsbefehl. Es ist wie hier gezeigt -

buildModel 'deeplearning', {
   "model_id":"deeplearning_model","training_frame":"allyear
   s2k.hex","ignored_columns":[
      "DepTime","CRSDepTime","ArrTime","CRSArrTime","FlightNum","TailNum",
      "ActualElapsedTime","CRSElapsedTime","AirTime","ArrDelay","DepDelay",
      "TaxiIn","TaxiOut","Cancelled","CancellationCode","Diverted",
      "CarrierDelay","WeatherDelay","NASDelay","SecurityDelay",
      "LateAircraftDelay","IsArrDelayed"],
   "ignore_const_cols":true,"res   ponse_column":"IsDepDelayed",
   "activation":"Rectifier","hidden":[200,200],"epochs":"100",
   "variable_importances":false,"balance_classes":false,
   "checkpoint":"","use_all_factor_levels":true,
   "train_samples_per_iteration":-2,"adaptive_rate":true,
   "input_dropout_ratio":0,"l1":0,"l2":0,"loss":"Automatic","score_interval":5,
   "score_training_samples":10000,"score_duty_cycle":0.1,"autoencoder":false,
   "overwrite_with_best_model":true,"target_ratio_comm_to_comp":0.02,
   "seed":6765686131094811000,"rho":0.99,"epsilon":1e-8,"max_w2":"Infinity",
   "initial_weight_distribution":"UniformAdaptive","classification_stop":0,
   "diagnostics":true,"fast_mode":true,"force_load_balance":true,
   "single_node_mode":false,"shuffle_training_data":false,"missing_values_handling":
   "MeanImputation","quiet_mode":false,"sparse":false,"col_major":false,
   "average_activation":0,"sparsity_beta":0,"max_categorical_features":2147483647,
   "reproducible":false,"export_weights_and_biases":false
}

Wie Sie im obigen Code sehen können, geben wir Deeplearning zum Erstellen des Modells mit mehreren Parametern an, die auf die entsprechenden Werte eingestellt sind, wie in der Dokumentation des Deeplearning-Modells angegeben. Wenn Sie diese Anweisung ausführen, dauert es länger als beim Erstellen des GLM-Modells. Sie sehen die folgende Ausgabe, wenn der Modellbau abgeschlossen ist, wenn auch mit unterschiedlichen Zeitpunkten.

Untersuchen der Ausgabe des Deep Learning-Modells

Dies erzeugt die Art der Ausgabe, die wie im vorherigen Fall mit der folgenden Anweisung untersucht werden kann.

getModel "deeplearning_model"

Wir werden die ROC-Kurvenausgabe wie unten gezeigt als Kurzreferenz betrachten.

Erweitern Sie wie im vorherigen Fall die verschiedenen Registerkarten und untersuchen Sie die verschiedenen Ausgaben.

Modell speichern

Nachdem Sie die Ausgabe verschiedener Modelle untersucht haben, entscheiden Sie sich für eines dieser Modelle in Ihrer Produktionsumgebung. Mit H20 können Sie dieses Modell als POJO (Plain Old Java Object) speichern.

Erweitern Sie das letzte Tag PREVIEW POJO in der Ausgabe, und Sie sehen den Java-Code für Ihr fein abgestimmtes Modell. Verwenden Sie dies in Ihrer Produktionsumgebung.

Als nächstes lernen wir eine sehr aufregende Funktion von H2O kennen. Wir werden lernen, wie man AutoML verwendet, um verschiedene Algorithmen basierend auf ihrer Leistung zu testen und zu bewerten.

Starten Sie zur Verwendung von AutoML ein neues Jupyter-Notizbuch und führen Sie die folgenden Schritte aus.

AutoML importieren

Importieren Sie zuerst das H2O- und AutoML-Paket mit den folgenden beiden Anweisungen in das Projekt:

import h2o
from h2o.automl import H2OAutoML

Initialisieren Sie H2O

Initialisieren Sie h2o mit der folgenden Anweisung:

h2o.init()

Sie sollten die Clusterinformationen auf dem Bildschirm sehen, wie im folgenden Screenshot gezeigt -

Lade Daten

Wir verwenden denselben iris.csv-Datensatz, den Sie zuvor in diesem Lernprogramm verwendet haben. Laden Sie die Daten mit der folgenden Anweisung:

data = h2o.import_file('iris.csv')

Datensatz vorbereiten

Wir müssen uns für die Features und die Vorhersagespalten entscheiden. Wir verwenden dieselben Funktionen und die Prädikationsspalte wie in unserem früheren Fall. Legen Sie die Features und die Ausgabespalte mit den folgenden beiden Anweisungen fest:

features = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width']
output = 'class'

Teilen Sie die Daten für Training und Tests im Verhältnis 80:20 auf -

train, test = data.split_frame(ratios=[0.8])

AutoML anwenden

Jetzt sind wir alle bereit, AutoML auf unseren Datensatz anzuwenden. Die AutoML wird für eine von uns festgelegte festgelegte Zeit ausgeführt und gibt uns das optimierte Modell. Wir richten die AutoML mit der folgenden Anweisung ein:

aml = H2OAutoML(max_models = 30, max_runtime_secs=300, seed = 1)

Der erste Parameter gibt die Anzahl der Modelle an, die bewertet und verglichen werden sollen.

Der zweite Parameter gibt die Zeit an, für die der Algorithmus ausgeführt wird.

Wir rufen jetzt die Zugmethode für das AutoML-Objekt auf, wie hier gezeigt -

aml.train(x = features, y = output, training_frame = train)

Wir geben das x als das zuvor erstellte Feature-Array an, das y als Ausgabevariable, um den vorhergesagten Wert und den Datenrahmen als anzugeben train Datensatz.

Führen Sie den Code aus. Sie müssen 5 Minuten warten (wir setzen max_runtime_secs auf 300), bis Sie die folgende Ausgabe erhalten:

Bestenliste drucken

Nach Abschluss der AutoML-Verarbeitung wird eine Rangliste erstellt, in der alle 30 ausgewerteten Algorithmen aufgeführt sind. Verwenden Sie den folgenden Code, um die ersten 10 Datensätze der Bestenliste anzuzeigen:

lb = aml.leaderboard
lb.head()

Bei der Ausführung generiert der obige Code die folgende Ausgabe:

Der DeepLearning-Algorithmus hat eindeutig die maximale Punktzahl.

Vorhersage von Testdaten

Nachdem Sie die Modelle eingestuft haben, können Sie die Leistung des am besten bewerteten Modells anhand Ihrer Testdaten sehen. Führen Sie dazu die folgende Code-Anweisung aus:

preds = aml.predict(test)

Die Verarbeitung wird eine Weile fortgesetzt und Sie sehen die folgende Ausgabe, wenn sie abgeschlossen ist.

Druckergebnis

Drucken Sie das vorhergesagte Ergebnis mit der folgenden Anweisung aus:

print (preds)

Nach Ausführung der obigen Anweisung sehen Sie das folgende Ergebnis:

Ranking für alle drucken

Wenn Sie die Ränge aller getesteten Algorithmen anzeigen möchten, führen Sie die folgende Codeanweisung aus:

lb.head(rows = lb.nrows)

Bei Ausführung der obigen Anweisung wird die folgende Ausgabe generiert (teilweise gezeigt) -

Fazit

H2O bietet eine benutzerfreundliche Open Source-Plattform für die Anwendung verschiedener ML-Algorithmen auf einen bestimmten Datensatz. Es bietet verschiedene statistische und ML-Algorithmen, einschließlich Deep Learning. Während des Tests können Sie die Parameter auf diese Algorithmen abstimmen. Sie können dies über die Befehlszeile oder die bereitgestellte webbasierte Oberfläche namens Flow tun. H2O unterstützt auch AutoML, das die Rangfolge unter den verschiedenen Algorithmen basierend auf ihrer Leistung bereitstellt. H2O funktioniert auch bei Big Data gut. Dies ist definitiv ein Segen für Data Scientist, die verschiedenen Modelle des maschinellen Lernens auf ihren Datensatz anzuwenden und das beste auszuwählen, das ihren Anforderungen entspricht.