H2O - Instalación

H2O se puede configurar y utilizar con cinco opciones diferentes que se enumeran a continuación:

  • Instalar en Python

  • Instalar en R

  • GUI de flujo basada en la web

  • Hadoop

  • Nube Anaconda

En las secciones siguientes, verá las instrucciones para la instalación de H2O según las opciones disponibles. Es probable que utilice una de las opciones.

Instalar en Python

Para ejecutar H2O con Python, la instalación requiere varias dependencias. Así que comencemos a instalar el conjunto mínimo de dependencias para ejecutar H2O.

Instalación de dependencias

Para instalar una dependencia, ejecute el siguiente comando pip:

$ pip install requests

Abra la ventana de su consola y escriba el comando anterior para instalar el paquete de solicitudes. La siguiente captura de pantalla muestra la ejecución del comando anterior en nuestra máquina Mac:

Después de instalar las solicitudes, debe instalar tres paquetes más como se muestra a continuación:

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

La lista más actualizada de dependencias está disponible en la página H2O GitHub. En el momento de escribir este artículo, las siguientes dependencias se enumeran en la página.

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

Eliminación de versiones anteriores

Después de instalar las dependencias anteriores, debe eliminar cualquier instalación de H2O existente. Para hacerlo, ejecute el siguiente comando:

$ pip uninstall h2o

Instalación de la última versión

Ahora, instalemos la última versión de H2O usando el siguiente comando:

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

Después de una instalación exitosa, debería ver el siguiente mensaje en la pantalla:

Installing collected packages: h2o
Successfully installed h2o-3.26.0.1

Prueba de la instalación

Para probar la instalación, ejecutaremos una de las aplicaciones de muestra proporcionadas en la instalación de H2O. Primero inicie el indicador de Python escribiendo el siguiente comando:

$ Python3

Una vez que se inicia el intérprete de Python, escriba la siguiente declaración de Python en el símbolo del sistema de Python:

>>>import h2o

El comando anterior importa el paquete H2O en su programa. A continuación, inicialice el sistema H2O con el siguiente comando:

>>>h2o.init()

Su pantalla mostraría la información del clúster y debería tener el siguiente aspecto en esta etapa:

Ahora, está listo para ejecutar el código de muestra. Escriba el siguiente comando en el indicador de Python y ejecútelo.

>>>h2o.demo("glm")

La demostración consta de un cuaderno de Python con una serie de comandos. Después de ejecutar cada comando, su salida se muestra inmediatamente en la pantalla y se le pedirá que presione la tecla para continuar con el siguiente paso. Aquí se muestra la captura de pantalla parcial sobre la ejecución de la última declaración en el cuaderno:

En esta etapa, su instalación de Python está completa y está listo para su propia experimentación.

Instalar en R

La instalación de H2O para el desarrollo de R es muy similar a la instalación de Python, excepto que usaría el indicador de R para la instalación.

Inicio de R Console

Inicie la consola R haciendo clic en el icono de la aplicación R en su máquina. La pantalla de la consola aparecería como se muestra en la siguiente captura de pantalla:

Su instalación de H2O se realizaría en el indicador R anterior. Si prefiere usar RStudio, escriba los comandos en la subventana de la consola R.

Eliminación de versiones anteriores

Para empezar, elimine las versiones anteriores usando el siguiente comando en el indicador de R:

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

Descarga de dependencias

Descargue las dependencias para H2O usando el siguiente código:

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

Instalación de H2O

Instale H2O escribiendo el siguiente comando en el indicador de R:

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

La siguiente captura de pantalla muestra el resultado esperado:

Hay otra forma de instalar H2O en R.

Instalar en R desde CRAN

Para instalar R desde CRAN, use el siguiente comando en el indicador de R:

> install.packages("h2o")

Se le pedirá que seleccione el espejo:

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

En su pantalla se muestra un cuadro de diálogo que muestra la lista de sitios espejo. Seleccione la ubicación más cercana o el espejo de su elección.

Prueba de instalación

En el indicador de R, escriba y ejecute el siguiente código:

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

La salida generada será como se muestra en la siguiente captura de pantalla:

Su instalación de H2O en R está completa ahora.

Instalación de Web GUI Flow

Para instalar GUI Flow, descargue el archivo de instalación del sitio de H20. Descomprima el archivo descargado en su carpeta preferida. Tenga en cuenta la presencia del archivo h2o.jar en la instalación. Ejecute este archivo en una ventana de comandos usando el siguiente comando:

$ java -jar h2o.jar

Después de un tiempo, aparecerá lo siguiente en la ventana de su consola.

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:

Para iniciar el flujo, abra la URL proporcionada http://localhost:54321en su navegador. Aparecerá la siguiente pantalla:

En esta etapa, la instalación de Flow está completa.

Instalar en Hadoop / Anaconda Cloud

A menos que sea un desarrollador experimentado, no pensaría en usar H2O en Big Data. Es suficiente decir aquí que los modelos H2O se ejecutan de manera eficiente en enormes bases de datos de varios terabytes. Si sus datos están en su instalación de Hadoop o en la nube, siga los pasos dados en el sitio H2O para instalarlos en su base de datos respectiva.

Ahora que ha instalado y probado H2O con éxito en su máquina, está listo para el desarrollo real. Primero, veremos el desarrollo desde un símbolo del sistema. En nuestras lecciones posteriores, aprenderemos cómo realizar pruebas de modelos en H2O Flow.

Desarrollo en el símbolo del sistema

Consideremos ahora el uso de H2O para clasificar plantas del conocido conjunto de datos de iris que está disponible gratuitamente para desarrollar aplicaciones de aprendizaje automático.

Inicie el intérprete de Python escribiendo el siguiente comando en su ventana de shell:

$ Python3

Esto inicia el intérprete de Python. Importe la plataforma h2o usando el siguiente comando:

>>> import h2o

Usaremos el algoritmo Random Forest para la clasificación. Esto se proporciona en el paquete H2ORandomForestEstimator. Importamos este paquete utilizando la declaración de importación de la siguiente manera:

>>> from h2o.estimators import H2ORandomForestEstimator

Inicializamos el entorno H2o llamando a su método init.

>>> h2o.init()

En la inicialización exitosa, debería ver el siguiente mensaje en la consola junto con la información del clúster.

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

Ahora, importaremos los datos del iris usando el método import_file en H2O.

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

El progreso se mostrará como se muestra en la siguiente captura de pantalla:

Una vez que el archivo se carga en la memoria, puede verificar esto mostrando las primeras 10 filas de la tabla cargada. Usas elhead método para hacerlo -

>>> data.head()

Verá el siguiente resultado en formato tabular.

La tabla también muestra los nombres de las columnas. Usaremos las primeras cuatro columnas como las características de nuestro algoritmo ML y la última clase de columna como la salida prevista. Especificamos esto en la llamada a nuestro algoritmo ML creando primero las siguientes dos variables.

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

A continuación, dividimos los datos en entrenamiento y prueba llamando al método split_frame.

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

Los datos se dividen en una proporción de 80:20. Usamos 80% de datos para entrenamiento y 20% para pruebas.

Ahora, cargamos el modelo de bosque aleatorio integrado en el sistema.

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

En la llamada anterior, establecemos el número de árboles en 50, la profundidad máxima del árbol en 20 y el número de pliegues para la validación cruzada en 10. Ahora necesitamos entrenar el modelo. Lo hacemos llamando al método train de la siguiente manera:

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

El método train recibe las características y la salida que creamos anteriormente como los dos primeros parámetros. El conjunto de datos de entrenamiento está configurado para entrenar, que es el 80% de nuestro conjunto de datos completo. Durante el entrenamiento, verá el progreso como se muestra aquí:

Ahora que el proceso de construcción del modelo ha terminado, es el momento de probar el modelo. Hacemos esto llamando al método model_performance en el objeto de modelo entrenado.

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

En la llamada al método anterior, enviamos datos de prueba como nuestro parámetro.

Ahora es el momento de ver el resultado, que es el rendimiento de nuestro modelo. Puede hacer esto simplemente imprimiendo la interpretación.

>>> print (performance)

Esto le dará el siguiente resultado:

El resultado muestra el error cuadrático medio (MSE), el error cuadrático medio raíz (RMSE), LogLoss e incluso la matriz de confusión.

Corriendo en Jupyter

Hemos visto la ejecución desde el comando y también hemos entendido el propósito de cada línea de código. Puede ejecutar el código completo en un entorno de Jupyter, ya sea línea por línea o el programa completo a la vez. La lista completa se da aquí:

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)

Ejecute el código y observe el resultado. Ahora puede apreciar lo fácil que es aplicar y probar un algoritmo de bosque aleatorio en su conjunto de datos. El poder del H20 va mucho más allá de esta capacidad. ¿Qué sucede si desea probar otro modelo en el mismo conjunto de datos para ver si puede obtener un mejor rendimiento? Esto se explica en nuestra sección siguiente.

Aplicar un algoritmo diferente

Ahora, aprenderemos cómo aplicar un algoritmo de aumento de gradiente a nuestro conjunto de datos anterior para ver cómo funciona. En la lista completa anterior, deberá realizar solo dos cambios menores como se resalta en el código a continuación:

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)

Ejecute el código y obtendrá el siguiente resultado:

Simplemente compare los resultados como MSE, RMSE, Confusion Matrix, etc. con el resultado anterior y decida cuál usar para la implementación de producción. De hecho, puede aplicar varios algoritmos diferentes para decidir cuál es el que mejor se adapta a su propósito.