H2O - Guide rapide

Vous a-t-on déjà demandé de développer un modèle d'apprentissage automatique sur une énorme base de données? En règle générale, le client vous fournira la base de données et vous demandera de faire certaines prédictions telles que qui seront les acheteurs potentiels; s'il peut y avoir une détection précoce des cas frauduleux, etc. Pour répondre à ces questions, votre tâche serait de développer un algorithme d'apprentissage automatique qui fournirait une réponse à la requête du client. Développer un algorithme de Machine Learning à partir de zéro n'est pas une tâche facile et pourquoi devriez-vous le faire alors qu'il existe plusieurs bibliothèques de Machine Learning prêtes à l'emploi disponibles sur le marché.

De nos jours, vous préférez utiliser ces bibliothèques, appliquer un algorithme bien testé à partir de ces bibliothèques et regarder ses performances. Si les performances n'étaient pas dans des limites acceptables, vous tenteriez soit d'affiner l'algorithme actuel, soit d'en essayer un tout à fait différent.

De même, vous pouvez essayer plusieurs algorithmes sur le même ensemble de données, puis choisir le meilleur qui répond de manière satisfaisante aux exigences du client. C'est là que H2O vient à votre secours. Il s'agit d'un cadre d'apprentissage automatique open source avec des implémentations entièrement testées de plusieurs algorithmes de ML largement acceptés. Il vous suffit de récupérer l'algorithme de son énorme référentiel et de l'appliquer à votre ensemble de données. Il contient les algorithmes statistiques et ML les plus utilisés.

Pour n'en citer que quelques-uns, il comprend les machines à gradient boosté (GBM), le modèle linéaire généralisé (GLM), l'apprentissage en profondeur et bien d'autres. Non seulement il prend également en charge la fonctionnalité AutoML qui classera les performances de différents algorithmes sur votre ensemble de données, réduisant ainsi vos efforts pour trouver le modèle le plus performant. H2O est utilisé dans le monde entier par plus de 18000 organisations et s'interface bien avec R et Python pour votre facilité de développement. C'est une plate-forme en mémoire qui offre de superbes performances.

Dans ce didacticiel, vous apprendrez d'abord à installer le H2O sur votre machine avec les options Python et R. Nous allons comprendre comment l'utiliser dans la ligne de commande afin que vous compreniez son fonctionnement en ligne. Si vous êtes un amoureux de Python, vous pouvez utiliser Jupyter ou tout autre IDE de votre choix pour développer des applications H2O. Si vous préférez R, vous pouvez utiliser RStudio pour le développement.

Dans ce tutoriel, nous examinerons un exemple pour comprendre comment travailler avec H2O. Nous apprendrons également comment changer l'algorithme dans le code de votre programme et comparer ses performances avec le précédent. Le H2O fournit également un outil Web pour tester les différents algorithmes de votre ensemble de données. C'est ce qu'on appelle Flow.

Le tutoriel vous présentera l'utilisation de Flow. Parallèlement, nous discuterons de l'utilisation d'AutoML qui identifiera l'algorithme le plus performant sur votre ensemble de données. N'êtes-vous pas impatient d'apprendre H2O? Continue de lire!

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 serait 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.

Appliquer 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.

Dans la dernière leçon, vous avez appris à créer des modèles ML basés sur H2O à l'aide de l'interface de ligne de commande. H2O Flow remplit le même objectif, mais avec une interface Web.

Dans les leçons suivantes, je vais vous montrer comment démarrer H2O Flow et exécuter un exemple d'application.

Démarrage de H2O Flow

L'installation H2O que vous avez téléchargée précédemment contient le fichier h2o.jar. Pour démarrer H2O Flow, exécutez d'abord ce jar à partir de l'invite de commande -

$ java -jar h2o.jar

Lorsque le fichier jar s'exécute avec succès, vous obtiendrez le message suivant sur la console -

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

Maintenant, ouvrez le navigateur de votre choix et tapez l'URL ci-dessus. Vous verriez le bureau Web H2O comme indiqué ici -

Il s'agit essentiellement d'un ordinateur portable similaire à Colab ou Jupyter. Je vais vous montrer comment charger et exécuter un exemple d'application dans ce bloc-notes tout en expliquant les différentes fonctionnalités de Flow. Cliquez sur le lien Afficher l'exemple de flux sur l'écran ci-dessus pour voir la liste des exemples fournis.

Je décrirai l'exemple de flux de retard des compagnies aériennes à partir de l'exemple.

Cliquez sur le lien Airlines Delay Flow dans la liste des échantillons comme indiqué dans la capture d'écran ci-dessous -

Une fois que vous avez confirmé, le nouveau bloc-notes serait chargé.

Effacement de toutes les sorties

Avant d'expliquer les instructions de code dans le bloc-notes, effaçons toutes les sorties, puis exécutons le bloc-notes progressivement. Pour effacer toutes les sorties, sélectionnez l'option de menu suivante -

Flow / Clear All Cell Contents

Ceci est montré dans la capture d'écran suivante -

Une fois que toutes les sorties sont effacées, nous exécuterons chaque cellule du cahier individuellement et examinerons sa sortie.

Exécution de la première cellule

Cliquez sur la première cellule. Un drapeau rouge apparaît sur la gauche indiquant que la cellule est sélectionnée. C'est comme indiqué dans la capture d'écran ci-dessous -

Le contenu de cette cellule n'est que le commentaire du programme écrit en langage MarkDown (MD). Le contenu décrit ce que fait l'application chargée. Pour exécuter la cellule, cliquez sur l'icône Exécuter comme indiqué dans la capture d'écran ci-dessous -

Vous ne verrez aucune sortie sous la cellule car il n'y a pas de code exécutable dans la cellule actuelle. Le curseur se déplace maintenant automatiquement vers la cellule suivante, qui est prête à être exécutée.

Importer des données

La cellule suivante contient l'instruction Python suivante -

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

L'instruction importe le fichier allyears2k.csv d'Amazon AWS dans le système. Lorsque vous exécutez la cellule, elle importe le fichier et vous donne la sortie suivante.

Configuration de l'analyseur de données

Maintenant, nous devons analyser les données et les adapter à notre algorithme ML. Cela se fait à l'aide de la commande suivante -

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

Lors de l'exécution de l'instruction ci-dessus, une boîte de dialogue de configuration d'installation apparaît. La boîte de dialogue vous permet plusieurs paramètres d'analyse du fichier. C'est comme indiqué dans la capture d'écran ci-dessous -

Dans cette boîte de dialogue, vous pouvez sélectionner l'analyseur souhaité dans la liste déroulante donnée et définir d'autres paramètres tels que le séparateur de champ, etc.

Analyse des données

L'instruction suivante, qui analyse en fait le fichier de données en utilisant la configuration ci-dessus, est longue et est comme indiqué ici -

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

Observez que les paramètres que vous avez définis dans la boîte de configuration sont répertoriés dans le code ci-dessus. Maintenant, exécutez cette cellule. Après un certain temps, l'analyse se termine et vous verrez la sortie suivante -

Examen de Dataframe

Après le traitement, il génère une trame de données, qui peut être examinée à l'aide de l'instruction suivante -

getFrameSummary "allyears2k.hex"

Lors de l'exécution de l'instruction ci-dessus, vous verrez la sortie suivante -

Désormais, vos données sont prêtes à être introduites dans un algorithme d'apprentissage automatique.

L'instruction suivante est un commentaire de programme qui indique que nous utiliserons le modèle de régression et spécifie la régularisation prédéfinie et les valeurs lambda.

Construire le modèle

Ensuite, vient la déclaration la plus importante et c'est la construction du modèle lui-même. Ceci est spécifié dans la déclaration suivante -

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
}

Nous utilisons glm, qui est une suite de modèles linéaires généralisés avec un type de famille défini sur binomial. Vous pouvez les voir mis en évidence dans la déclaration ci-dessus. Dans notre cas, la sortie attendue est binaire et c'est pourquoi nous utilisons le type binomial. Vous pouvez examiner les autres paramètres par vous-même; par exemple, regardez alpha et lambda que nous avions spécifiés précédemment. Reportez-vous à la documentation du modèle GLM pour l'explication de tous les paramètres.

Maintenant, exécutez cette instruction. Lors de l'exécution, la sortie suivante sera générée -

Certes, le temps d'exécution serait différent sur votre machine. Maintenant, vient la partie la plus intéressante de cet exemple de code.

Examen de la sortie

Nous sortons simplement le modèle que nous avons construit en utilisant l'instruction suivante -

getModel "glm_model"

Notez que glm_model est l'ID de modèle que nous avons spécifié comme paramètre model_id lors de la construction du modèle dans l'instruction précédente. Cela nous donne un énorme résultat détaillant les résultats avec plusieurs paramètres variables. Une sortie partielle du rapport est affichée dans la capture d'écran ci-dessous -

Comme vous pouvez le voir dans la sortie, cela indique que c'est le résultat de l'exécution de l'algorithme de modélisation linéaire généralisée sur votre ensemble de données.

Juste au-dessus de l'HISTORIQUE DES SCORES, vous voyez la balise MODEL PARAMETERS, développez-la et vous verrez la liste de tous les paramètres qui sont utilisés lors de la construction du modèle. Ceci est montré dans la capture d'écran ci-dessous.

De même, chaque balise fournit une sortie détaillée d'un type spécifique. Développez vous-même les différentes balises pour étudier les sorties de différents types.

Construire un autre modèle

Ensuite, nous allons construire un modèle de Deep Learning sur notre dataframe. L'instruction suivante dans l'exemple de code est simplement un commentaire de programme. L'instruction suivante est en fait une commande de création de modèle. C'est comme indiqué ici -

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
}

Comme vous pouvez le voir dans le code ci-dessus, nous spécifions le deeplearning pour construire le modèle avec plusieurs paramètres définis sur les valeurs appropriées comme spécifié dans la documentation du modèle de deeplearning. Lorsque vous exécutez cette instruction, cela prendra plus de temps que la création du modèle GLM. Vous verrez la sortie suivante une fois la construction du modèle terminée, mais avec des horaires différents.

Examen de la sortie du modèle d'apprentissage en profondeur

Cela génère le type de sortie, qui peut être examiné à l'aide de l'instruction suivante comme dans le cas précédent.

getModel "deeplearning_model"

Nous examinerons la sortie de la courbe ROC comme indiqué ci-dessous pour une référence rapide.

Comme dans le cas précédent, développez les différents onglets et étudiez les différentes sorties.

Enregistrer le modèle

Après avoir étudié la sortie de différents modèles, vous décidez d'en utiliser un dans votre environnement de production. H20 vous permet de sauvegarder ce modèle en tant que POJO (Plain Old Java Object).

Développez la dernière balise PREVIEW POJO dans la sortie et vous verrez le code Java pour votre modèle affiné. Utilisez ceci dans votre environnement de production.

Ensuite, nous découvrirons une fonctionnalité très intéressante de H2O. Nous allons apprendre à utiliser AutoML pour tester et classer divers algorithmes en fonction de leurs performances.

Pour utiliser AutoML, démarrez un nouveau bloc-notes Jupyter et suivez les étapes ci-dessous.

Importer AutoML

Importez d'abord le package H2O et AutoML dans le projet à l'aide des deux instructions suivantes -

import h2o
from h2o.automl import H2OAutoML

Initialiser H2O

Initialisez h2o en utilisant l'instruction suivante -

h2o.init()

Vous devriez voir les informations du cluster sur l'écran comme indiqué dans la capture d'écran ci-dessous -

Chargement des données

Nous utiliserons le même ensemble de données iris.csv que vous avez utilisé précédemment dans ce didacticiel. Chargez les données à l'aide de l'instruction suivante -

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

Préparation de l'ensemble de données

Nous devons décider des fonctionnalités et des colonnes de prédiction. Nous utilisons les mêmes fonctionnalités et la colonne de prédication que dans notre cas précédent. Définissez les fonctionnalités et la colonne de sortie à l'aide des deux instructions suivantes -

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

Divisez les données dans un rapport 80:20 pour la formation et les tests -

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

Application d'AutoML

Maintenant, nous sommes tous prêts à appliquer AutoML sur notre ensemble de données. L'AutoML fonctionnera pendant une durée fixe définie par nos soins et nous donnera le modèle optimisé. Nous configurons AutoML en utilisant l'instruction suivante -

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

Le premier paramètre spécifie le nombre de modèles que nous voulons évaluer et comparer.

Le deuxième paramètre spécifie la durée pendant laquelle l'algorithme s'exécute.

Nous appelons maintenant la méthode train sur l'objet AutoML comme indiqué ici -

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

Nous spécifions le x comme le tableau de caractéristiques que nous avons créé précédemment, le y comme variable de sortie pour indiquer la valeur prédite et le dataframe comme train base de données.

Exécutez le code, vous devrez attendre 5 minutes (nous définissons le max_runtime_secs sur 300) jusqu'à ce que vous obteniez la sortie suivante -

Impression du classement

Une fois le traitement AutoML terminé, il crée un classement classant tous les 30 algorithmes qu'il a évalués. Pour voir les 10 premiers enregistrements du classement, utilisez le code suivant -

lb = aml.leaderboard
lb.head()

Lors de l'exécution, le code ci-dessus générera la sortie suivante -

De toute évidence, l'algorithme DeepLearning a obtenu le score maximum.

Prédire sur les données de test

Maintenant que vous avez classé les modèles, vous pouvez voir les performances du modèle le mieux noté sur vos données de test. Pour ce faire, exécutez l'instruction de code suivante -

preds = aml.predict(test)

Le traitement se poursuit pendant un certain temps et vous verrez la sortie suivante à la fin.

Résultat d'impression

Imprimez le résultat prévu à l'aide de l'instruction suivante -

print (preds)

Lors de l'exécution de l'instruction ci-dessus, vous verrez le résultat suivant -

Impression du classement pour tous

Si vous voulez voir les rangs de tous les algorithmes testés, exécutez l'instruction de code suivante -

lb.head(rows = lb.nrows)

Lors de l'exécution de l'instruction ci-dessus, la sortie suivante sera générée (partiellement affichée) -

Conclusion

H2O fournit une plate-forme open source facile à utiliser pour appliquer différents algorithmes de ML sur un ensemble de données donné. Il fournit plusieurs algorithmes statistiques et ML, y compris l'apprentissage en profondeur. Pendant les tests, vous pouvez affiner les paramètres de ces algorithmes. Vous pouvez le faire à l'aide de la ligne de commande ou de l'interface Web fournie appelée Flow. H2O prend également en charge AutoML qui fournit le classement parmi les différents algorithmes en fonction de leurs performances. H2O fonctionne également bien sur le Big Data. C'est certainement une aubaine pour Data Scientist d'appliquer les différents modèles de Machine Learning à leur ensemble de données et de choisir le meilleur pour répondre à leurs besoins.

↰ Previous page

H2O - Guide rapide

Installer en Python

Installation des dépendances

Suppression des anciennes versions

Installation de la dernière version

Test de l'installation

Installer dans R

Démarrage de R Console

Suppression des anciennes versions

Téléchargement des dépendances

Installation de H2O

Installer dans R depuis CRAN

Tester l'installation

Installation de Web GUI Flow

Installer sur Hadoop / Anaconda Cloud

Développement dans l'invite de commande

Courir dans Jupyter

Appliquer un algorithme différent

Démarrage de H2O Flow

Effacement de toutes les sorties

Exécution de la première cellule

Importer des données

Configuration de l'analyseur de données

Analyse des données

Examen de Dataframe

Construire le modèle

Examen de la sortie

Construire un autre modèle

Examen de la sortie du modèle d'apprentissage en profondeur

Enregistrer le modèle

Importer AutoML

Initialiser H2O

Chargement des données

Préparation de l'ensemble de données

Application d'AutoML

Impression du classement

Prédire sur les données de test

Résultat d'impression

Impression du classement pour tous

Conclusion

Tutoriel H2O

Ressources utiles H2O