H2O - Installation

H2O peut être configuré et utilisé avec cinq options différentes comme indiqué ci-dessous -

  • Installer en Python

  • Installer dans R

  • Interface graphique Web Flow

  • Hadoop

  • Nuage d'Anaconda

Dans nos sections suivantes, vous verrez les instructions pour l'installation de H2O en fonction des options disponibles. Vous utiliserez probablement l'une des options.

Installer en Python

Pour exécuter H2O avec Python, l'installation nécessite plusieurs dépendances. Commençons donc par installer l'ensemble minimum de dépendances pour exécuter H2O.

Installation des dépendances

Pour installer une dépendance, exécutez la commande pip suivante -

$ pip install requests

Ouvrez la fenêtre de votre console et tapez la commande ci-dessus pour installer le package de requêtes. La capture d'écran suivante montre l'exécution de la commande ci-dessus sur notre machine Mac -

Après avoir installé les requêtes, vous devez installer trois autres packages comme indiqué ci-dessous -

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

La liste la plus à jour des dépendances est disponible sur la page H2O GitHub. Au moment de la rédaction de cet article, les dépendances suivantes sont répertoriées sur la page.

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

Suppression des anciennes versions

Après avoir installé les dépendances ci-dessus, vous devez supprimer toute installation H2O existante. Pour ce faire, exécutez la commande suivante -

$ pip uninstall h2o

Installation de la dernière version

Maintenant, installons la dernière version de H2O en utilisant la commande suivante -

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

Après une installation réussie, vous devriez voir le message suivant s'afficher à l'écran -

Installing collected packages: h2o
Successfully installed h2o-3.26.0.1

Test de l'installation

Pour tester l'installation, nous exécuterons l'un des exemples d'application fournis dans l'installation H2O. Commencez par démarrer l'invite Python en tapant la commande suivante -

$ Python3

Une fois l'interpréteur Python démarré, tapez l'instruction Python suivante sur l'invite de commande Python -

>>>import h2o

La commande ci-dessus importe le package H2O dans votre programme. Ensuite, initialisez le système H2O à l'aide de la commande suivante -

>>>h2o.init()

Votre écran afficherait les informations du cluster et devrait ressembler à ce qui suit à ce stade -

Vous êtes maintenant prêt à exécuter l'exemple de code. Tapez la commande suivante sur l'invite Python et exécutez-la.

>>>h2o.demo("glm")

La démo consiste en un bloc-notes Python avec une série de commandes. Après avoir exécuté chaque commande, sa sortie est immédiatement affichée à l'écran et il vous sera demandé d'appuyer sur la touche pour passer à l'étape suivante. La capture d'écran partielle sur l'exécution de la dernière instruction dans le cahier est affichée ici -

À ce stade, votre installation Python est terminée et vous êtes prêt pour votre propre expérimentation.

Installer dans R

L'installation de H2O pour le développement R est très similaire à son installation pour Python, sauf que vous utiliseriez l'invite R pour l'installation.

Démarrage de R Console

Démarrez la console R en cliquant sur l'icône de l'application R sur votre machine. L'écran de la console apparaîtrait comme indiqué dans la capture d'écran suivante -

Votre installation H2O sera effectuée à l'invite R ci-dessus. Si vous préférez utiliser RStudio, saisissez les commandes dans la sous-fenêtre de la console R.

Suppression des anciennes versions

Pour commencer, supprimez les anciennes versions à l'aide de la commande suivante à l'invite R -

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

Téléchargement des dépendances

Téléchargez les dépendances pour H2O en utilisant le code suivant -

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

Installation de H2O

Installez H2O en tapant la commande suivante sur l'invite R -

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

La capture d'écran suivante montre la sortie attendue -

Il existe une autre façon d'installer H2O dans R.

Installer dans R depuis CRAN

Pour installer R à partir de CRAN, utilisez la commande suivante à l'invite R -

> install.packages("h2o")

Il vous sera demandé de sélectionner le miroir -

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

Une boîte de dialogue affichant la liste des sites miroirs s'affiche sur votre écran. Sélectionnez l'emplacement le plus proche ou le miroir de votre choix.

Tester l'installation

À l'invite R, tapez et exécutez le code suivant -

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

La sortie générée sera comme indiqué dans la capture d'écran suivante -

Votre installation H2O dans R est maintenant terminée.

Installation de Web GUI Flow

Pour installer GUI Flow, téléchargez le fichier d'installation à partir du site H20. Décompressez le fichier téléchargé dans votre dossier préféré. Notez la présence du fichier h2o.jar dans l'installation. Exécutez ce fichier dans une fenêtre de commande à l'aide de la commande suivante -

$ java -jar h2o.jar

Après un certain temps, ce qui suit apparaîtra dans la fenêtre de votre console.

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:

Pour démarrer le Flow, ouvrez l'URL donnée http://localhost:54321dans votre navigateur. L'écran suivant apparaîtra -

À ce stade, votre installation Flow est terminée.

Installer sur Hadoop / Anaconda Cloud

À moins que vous ne soyez un développeur chevronné, vous ne penseriez pas à utiliser H2O sur le Big Data. Il suffit de dire ici que les modèles H2O fonctionnent efficacement sur d'énormes bases de données de plusieurs téraoctets. Si vos données se trouvent sur votre installation Hadoop ou dans le Cloud, suivez les étapes indiquées sur le site H2O pour l'installer pour votre base de données respective.

Maintenant que vous avez installé et testé H2O avec succès sur votre machine, vous êtes prêt pour un vrai développement. Tout d'abord, nous verrons le développement à partir d'une invite de commande. Dans nos leçons suivantes, nous apprendrons à faire des tests de modèle dans H2O Flow.

Développement dans l'invite de commande

Considérons maintenant l'utilisation de H2O pour classer les plantes du jeu de données iris bien connu qui est disponible gratuitement pour le développement d'applications d'apprentissage automatique.

Démarrez l'interpréteur Python en tapant la commande suivante dans votre fenêtre shell -

$ Python3

Cela démarre l'interpréteur Python. Importez la plateforme h2o à l'aide de la commande suivante -

>>> import h2o

Nous utiliserons l'algorithme Random Forest pour la classification. Ceci est fourni dans le package H2ORandomForestEstimator. Nous importons ce package en utilisant l'instruction d'importation comme suit -

>>> from h2o.estimators import H2ORandomForestEstimator

Nous initialisons l'environnement H2o en appelant sa méthode init.

>>> h2o.init()

En cas d'initialisation réussie, vous devriez voir le message suivant sur la console avec les informations sur le cluster.

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

Maintenant, nous allons importer les données d'iris en utilisant la méthode import_file dans H2O.

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

La progression s'affiche comme indiqué dans la capture d'écran suivante -

Une fois le fichier chargé dans la mémoire, vous pouvez le vérifier en affichant les 10 premières lignes de la table chargée. Vous utilisez lehead méthode pour le faire -

>>> data.head()

Vous verrez la sortie suivante au format tabulaire.

Le tableau affiche également les noms des colonnes. Nous utiliserons les quatre premières colonnes comme fonctionnalités pour notre algorithme ML et la dernière classe de colonnes comme sortie prévue. Nous spécifions cela dans l'appel à notre algorithme ML en créant d'abord les deux variables suivantes.

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

Ensuite, nous divisons les données en entraînement et en test en appelant la méthode split_frame.

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

Les données sont réparties dans le rapport 80:20. Nous utilisons 80% de données pour la formation et 20% pour les tests.

Maintenant, nous chargeons le modèle Random Forest intégré dans le système.

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

Dans l'appel ci-dessus, nous fixons le nombre d'arbres à 50, la profondeur maximale de l'arbre à 20 et le nombre de plis pour la validation croisée à 10. Nous devons maintenant entraîner le modèle. Nous le faisons en appelant la méthode train comme suit -

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

La méthode train reçoit les fonctionnalités et la sortie que nous avons créées précédemment en tant que deux premiers paramètres. L'ensemble de données d'entraînement est configuré pour s'entraîner, ce qui correspond à 80% de notre ensemble de données complet. Pendant l'entraînement, vous verrez la progression comme indiqué ici -

Maintenant que le processus de création du modèle est terminé, il est temps de tester le modèle. Pour ce faire, nous appelons la méthode model_performance sur l'objet modèle entraîné.

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

Dans l'appel de méthode ci-dessus, nous avons envoyé des données de test en tant que paramètre.

Il est temps maintenant de voir la sortie, qui est la performance de notre modèle. Vous faites cela en imprimant simplement la performance.

>>> print (performance)

Cela vous donnera la sortie suivante -

La sortie affiche l'erreur quadratique moyenne (MSE), l'erreur quadratique moyenne (RMSE), la perte logarithmique et même la matrice de confusion.

Courir dans Jupyter

Nous avons vu l'exécution de la commande et également compris le but de chaque ligne de code. Vous pouvez exécuter l'intégralité du code dans un environnement Jupyter, soit ligne par ligne, soit l'ensemble du programme à la fois. La liste complète est donnée ici -

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)

Exécutez le code et observez la sortie. Vous pouvez maintenant apprécier à quel point il est facile d'appliquer et de tester un algorithme Random Forest sur votre ensemble de données. La puissance du H20 va bien au-delà de cette capacité. Que faire si vous souhaitez essayer un autre modèle sur le même jeu de données pour voir si vous pouvez obtenir de meilleures performances. Ceci est expliqué dans notre section suivante.

Application d'un algorithme différent

Maintenant, nous allons apprendre comment appliquer un algorithme d'amplification de gradient à notre ensemble de données précédent pour voir comment il fonctionne. Dans la liste complète ci-dessus, vous n'aurez besoin de faire que deux modifications mineures, comme indiqué dans le code ci-dessous -

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)

Exécutez le code et vous obtiendrez la sortie suivante -

Comparez simplement les résultats tels que MSE, RMSE, Confusion Matrix, etc. avec la sortie précédente et décidez lequel utiliser pour le déploiement en production. En fait, vous pouvez appliquer plusieurs algorithmes différents pour décider du meilleur qui répond à votre objectif.