Menu
R-blogueurs
Nouvelles et tutoriels sur R fournis par des centaines de blogueurs sur R
Une introduction à H2O à l'aide de R
Publié par R sur [Link]
[Cet article a d'abord été publié sur R sur [Link] , et a aimablement contribué aux R-blogueurs ]. (Vous pouvez
signaler un problème concernant le contenu de cette page ici )
Vous souhaitez partager votre contenu sur les R-blogueurs? cliquez ici si vous avez un blog, ou ici si vous n'en avez
pas.
Partager Tweet
1. Introduction
Dans cet article, nous discutons de la plate-forme d'apprentissage automatique H2O. Nous parlons de ce
qu'est H2O et de la façon de commencer avec R - nous créons une forêt aléatoire que nous utilisons pour
classer l'ensemble de données Iris.
2. Qu'est-ce que H2O?
La définition trouvée sur la page Github de H2O est beaucoup à prendre, surtout si vous débutez avec H2O:
«H2O est une plate-forme en mémoire pour l'apprentissage automatique distribué et évolutif. H2O utilise
des interfaces familières comme R, Python, Scala, Java, JSON et l'interface Web / bloc-notes Flow, et
fonctionne de manière transparente avec les technologies de Big Data comme Hadoop et Spark. »
Nous passons le reste de la section 2 ainsi que la section 3 à discuter des points saillants de la définition
ci-dessus.
2.1 H2O est une plateforme en mémoire
H2O est une «plateforme en mémoire». Dire que c'est en mémoire signifie que les données utilisées sont
chargées dans la mémoire principale (RAM). La lecture à partir de la mémoire principale (également
appelée mémoire principale) est généralement beaucoup plus rapide que la mémoire secondaire (comme
un disque dur).
H2O est une «plateforme». Une plate-forme est un logiciel qui peut être utilisé pour construire quelque
chose - dans ce cas, des modèles d'apprentissage automatique.
En mettant cela ensemble, nous savons maintenant que H2O est un environnement en mémoire pour la
construction de modèles d'apprentissage automatique.
2.2 H2O est distribué et évolutif
H2O peut être exécuté sur un cluster. Hadoop est un exemple de cluster pouvant exécuter H2O.
H2O est censé être distribué car votre objet peut être réparti entre plusieurs nœuds de votre cluster. H2O le
fait en utilisant une valeur de clé distribuée (DKV). Vous pouvez en savoir plus ici , mais essentiellement ce
que cela signifie, c'est que tout objet que vous créez dans H2O peut être réparti entre plusieurs nœuds du
cluster.
La partie valeur-clé de DKV signifie que lorsque vous chargez des données dans H2O, vous récupérez une
clé dans une table de hachage contenant votre objet (potentiellement distribué).
3. Comment H2O fonctionne sous le capot
Nous avons parlé plus tôt de H2O étant une plate-forme. Il est important de faire la distinction entre
l'interface R pour H2O et H2O lui-même. H2O peut parfaitement exister sans R. H2O n'est qu'un .jar qui
peut être exécuté seul. Si vous ne savez pas (ou ne vous souciez pas particulièrement) de ce qu'est un .jar -
pensez-y simplement comme du code Java empaqueté avec tout ce dont vous avez besoin pour l'exécuter.
Lorsque vous démarrez H2O, vous créez réellement un serveur qui peut répondre aux appels REST . Encore
une fois, vous n'avez pas vraiment besoin de savoir comment fonctionne REST pour utiliser H2O. Mais si
vous vous en souciez, sachez simplement que vous pouvez utiliser n'importe quel client HTTP pour parler
avec une instance H2O.
R est juste une interface client pour H2O. Toutes les fonctions R que vous appelez lorsque vous travaillez
avec H2O appellent réellement H2O à l'aide d'une API REST (une demande JSON POST) sous le capot. La
bibliothèque Python H2O, ainsi que l' interface utilisateur Flow , s'interfacent avec H2O de la même manière.
Si tout cela est très déroutant, pensez-y comme ceci: vous utilisez R pour envoyer des commandes à H2O.
Vous pouvez également utiliser Flow ou Python pour envoyer des commandes.
4. Exécuter un exemple
4.1 Installation de H2O
Vous pouvez installer H2O en utilisant R: [Link]("h2o"). Si vous rencontrez des problèmes
avec cela, jetez un œil ici.
4.2 Démarrage de H2O et chargement des données
Nous devons d'abord charger les packages que nous utiliserons: h2oet datasets. Nous chargeons ce
dernier car nous utiliserons le célèbre ensemble de données Iris , qui fait partie du datasetspackage.
library(datasets)
library(h2o)
L'ensemble de données Iris contient les attributs de trois espèces de fleurs d'iris.
Chargeons l'ensemble de données iris et démarrons notre instance H2O:
[Link](nthreads = -1)
data(iris)
Par défaut, H2O démarre en utilisant 2 cœurs. En appelant [Link](nthreads = -1), avec nthreads
= -1, nous utilisons tous les cœurs disponibles.
Edit: il ne prend plus par défaut deux cœurs (selon ce tweet du scientifique en chef de H2O):
Belle publication! BTW, H2O dans R ne sont plus par défaut à 2 cœurs, vous pouvez donc le faire
[Link]()maintenant.
- Erin LeDell ( @ledell ) 19 décembre 2018
Si cela [Link]()a réussi, vous devriez avoir une instance de H2O fonctionnant localement! Vous
pouvez le vérifier en accédant à http: // localhost: 54321 . Là, vous devriez voir l'interface utilisateur Flow.
Le jeu de données iris est maintenant chargé dans R. Cependant, il n'est pas encore dans H2O. Allons de
l'avant et chargons les données de l'iris dans notre instance H2O:
[Link] <- as.h2o(iris)
[Link]()
[Link]()répertorie les trames de données que vous avez chargées dans H2O. À l'heure actuelle, vous ne
devriez en voir qu'un: l'iris.
Commençons à enquêter sur cette trame de données. Nous pouvons obtenir les statistiques récapitulatives
des différentes colonnes:
[Link]([Link])
## Label Type Missing Zeros PosInf NegInf Min Max Mean Si
gma
## 1 [Link] real 0 0 0 0 4.3 7.9 5.843333 0.8280
661
## 2 [Link] real 0 0 0 0 2.0 4.4 3.057333 0.4358
663
## 3 [Link] real 0 0 0 0 1.0 6.9 3.758000 1.7652
982
## 4 [Link] real 0 0 0 0 0.1 2.5 1.199333 0.7622
377
## 5 Species enum 0 50 0 0 0.0 2.0 NA
NA
## Cardinality
## 1 NA
## 2 NA
## 3 NA
## 4 NA
## 5 3
Nous pouvons également utiliser H2O pour tracer des histogrammes:
[Link]([Link]$[Link])
Vous pouvez utiliser la syntaxe R familière pour modifier votre trame de données H2O:
[Link]$foo <- [Link]$[Link] + 2
Si nous exécutons maintenant [Link]([Link]), nous devrions voir cette variable
supplémentaire:
[Link]([Link])
## Label Type Missing Zeros PosInf NegInf Min Max Mean Si
gma
## 1 [Link] real 0 0 0 0 4.3 7.9 5.843333 0.8280
661
## 2 [Link] real 0 0 0 0 2.0 4.4 3.057333 0.4358
663
## 3 [Link] real 0 0 0 0 1.0 6.9 3.758000 1.7652
982
## 4 [Link] real 0 0 0 0 0.1 2.5 1.199333 0.7622
377
## 5 Species enum 0 50 0 0 0.0 2.0 NA
NA
## 6 foo real 0 0 0 0 6.3 9.9 7.843333 0.8280
661
## Cardinality
## 1 NA
## 2 NA
## 3 NA
## 4 NA
## 5 3
## 6 NA
(Ce que je ne comprends toujours pas, c'est pourquoi nous ne voyons pas cette colonne supplémentaire de
l'interface utilisateur Flow. Si quelqu'un le sait, faites-le moi savoir dans les commentaires!)
Mais nous n'avons pas vraiment besoin de cette colonne absurde, alors débarrassons-nous d'elle:
[Link]$foo <- NULL
Nous pouvons également récupérer notre trame de données dans R, à partir de H2O:
r_df <- [Link]([Link])
4.3 Construire un modèle
Notre instance H2O est opérationnelle et contient quelques données. Allons de l'avant et faisons un peu
d'apprentissage automatique - implémentons une forêt aléatoire.
Tout d'abord, nous diviserons nos données en un ensemble de formation et un ensemble de test. Je ne vais
pas définir explicitement un ensemble de validation, car l'algorithme utilisera à la place l' erreur hors du sac
.
splits <- [Link](data = [Link],
ratios = c(0.8), #partition data into 80% and 20
% chunks
seed = 198)
train <- splits[[1]]
test <- splits[[2]]
[Link]()utilise un fractionnement approximatif. Autrement dit, il ne divisera pas les données
en une répartition exacte de 80% à 20%. Définir la graine nous permet de créer des résultats reproductibles.
Nous pouvons utiliser [Link]()pour vérifier le nombre de rangées dans nos trains et ensembles de
test.
print(paste0("Number of rows in train set: ", [Link](train)))
## [1] "Number of rows in train set: 117"
print(paste0("Number of rows in test set: ", [Link](test)))
## [1] "Number of rows in test set: 33"
Appelons ensuite [Link]()pour créer notre modèle:
rf <- [Link](x = c("[Link]", "[Link]", "[Link]"
, "[Link]"),
y = c("Species"),
training_frame = train,
model_id = "[Link]",
seed = 1234)
Les paramètres xet yspécifient nos variables indépendantes et dépendantes, respectivement. Le
training_framejeu d'apprentissage spécifié, et model_idest le nom du modèle, dans H2O (à ne pas
confondre avec la variable rfdans le code ci-dessus - rfest la poignée R; alors [Link] H2O appelle le
modèle). seedest utilisé pour la reproductibilité.
Nous pouvons obtenir les détails du modèle simplement en imprimant le modèle:
print(rf)
## Model Details:
## ==============
##
## H2OMultinomialModel: drf
## Model ID: [Link]
## Model Summary:
## number_of_trees number_of_internal_trees model_size_in_bytes min_dept
h
## 1 50 150 18941
1
## max_depth mean_depth min_leaves max_leaves mean_leaves
## 1 7 3.26000 2 12 5.41333
##
##
## H2OMultinomialMetrics: drf
## ** Reported on training data. **
## ** Metrics reported on Out-Of-Bag training samples **
##
## Training Set Metrics:
## =====================
##
## Extract training frame with `[Link]("RTMP_sid_8ebc_7")`
## MSE: (Extract with `[Link]`) 0.03286954
## RMSE: (Extract with `[Link]`) 0.1812996
## Logloss: (Extract with `[Link]`) 0.09793089
## Mean Per-Class Error: 0.0527027
## Confusion Matrix: Extract with `[Link](,train = TRUE)`)
## =======================================================================
==
## Confusion Matrix: Row labels: Actual class; Column labels: Predicted cl
ass
## setosa versicolor virginica Error Rate
## setosa 40 0 0 0.0000 = 0 / 40
## versicolor 0 38 2 0.0500 = 2 / 40
## virginica 0 4 33 0.1081 = 4 / 37
## Totals 40 42 35 0.0513 = 6 / 117
##
## Hit Ratio Table: Extract with `h2o.hit_ratio_table(,train = TRUE)`
## =======================================================================
## Top-3 Hit Ratios:
## k hit_ratio
## 1 1 0.948718
## 2 2 1.000000
## 3 3 1.000000
Cela semble plutôt bien. Mais voyons comment le modèle fonctionne sur l'ensemble de test:
rf_perf1 <- [Link](model = rf, newdata = test)
print(rf_perf1)
## H2OMultinomialMetrics: drf
##
## Test Set Metrics:
## =====================
##
## MSE: (Extract with `[Link]`) 0.05806405
## RMSE: (Extract with `[Link]`) 0.2409648
## Logloss: (Extract with `[Link]`) 0.1708688
## Mean Per-Class Error: 0.1102564
## Confusion Matrix: Extract with `[Link](, )`)
## =======================================================================
==
## Confusion Matrix: Row labels: Actual class; Column labels: Predicted cl
ass
## setosa versicolor virginica Error Rate
## setosa 10 0 0 0.0000 = 0 / 10
## versicolor 0 9 1 0.1000 = 1 / 10
## virginica 0 3 10 0.2308 = 3 / 13
## Totals 10 12 11 0.1212 = 4 / 33
##
## Hit Ratio Table: Extract with `h2o.hit_ratio_table(, )`
## =======================================================================
## Top-3 Hit Ratios:
## k hit_ratio
## 1 1 0.878788
## 2 2 1.000000
## 3 3 1.000000
Enfin, utilisons notre modèle pour faire des prédictions:
predictions <- [Link](rf, test)
print(predictions)
## predict setosa versicolor virginica
## 1 setosa 0.9969698 0 0.00303019
## 2 setosa 0.9969698 0 0.00303019
## 3 setosa 0.9969698 0 0.00303019
## 4 setosa 0.9969698 0 0.00303019
## 5 setosa 0.9969698 0 0.00303019
## 6 setosa 0.9969698 0 0.00303019
##
## [33 rows x 4 columns]
5. Conclusion
Cet article a expliqué ce qu'est H2O et comment l'utiliser à partir de R. Le code complet utilisé dans cet
article peut être trouvé ici.
Partager Tweet
Pour laisser un commentaire à l'auteur, veuillez suivre le lien et commenter sur son blog: R sur [Link]
.
[Link] propose des mises à jour quotidiennes par e-mail sur les nouvelles de R et des tutoriels
sur l' apprentissage de R et de nombreux autres sujets. Cliquez ici si vous souhaitez publier ou trouver un
emploi en R / data science .
Vous souhaitez partager votre contenu sur les R-blogueurs? cliquez ici si vous avez un blog, ou ici si vous
n'en avez pas.
3 décembre 2018
" Précédent Suivant "
Voir le site complet
Fièrement propulsé par WordPress