H2O - Guía rápida

¿Alguna vez le han pedido que desarrolle un modelo de aprendizaje automático en una base de datos enorme? Normalmente, el cliente le proporcionará la base de datos y le pedirá que haga ciertas predicciones, como quiénes serán los compradores potenciales; si puede haber una detección temprana de casos fraudulentos, etc. Para responder a estas preguntas, su tarea sería desarrollar un algoritmo de aprendizaje automático que dé respuesta a la consulta del cliente. Desarrollar un algoritmo de aprendizaje automático desde cero no es una tarea fácil y por qué debería hacerlo cuando hay varias bibliotecas de aprendizaje automático listas para usar disponibles en el mercado.

En estos días, preferiría utilizar estas bibliotecas, aplicar un algoritmo bien probado de estas bibliotecas y observar su rendimiento. Si el rendimiento no estuviera dentro de los límites aceptables, intentaría ajustar el algoritmo actual o probar uno completamente diferente.

Del mismo modo, puede probar varios algoritmos en el mismo conjunto de datos y luego elegir el mejor que satisfaga los requisitos del cliente. Aquí es donde H2O viene a su rescate. Es un marco de aprendizaje automático de código abierto con implementaciones totalmente probadas de varios algoritmos ML ampliamente aceptados. Solo tiene que tomar el algoritmo de su enorme repositorio y aplicarlo a su conjunto de datos. Contiene los algoritmos estadísticos y ML más utilizados.

Para mencionar algunos aquí, incluye máquinas impulsadas por gradientes (GBM), modelo lineal generalizado (GLM), aprendizaje profundo y muchos más. No solo que también es compatible con la funcionalidad AutoML que clasificará el rendimiento de diferentes algoritmos en su conjunto de datos, reduciendo así sus esfuerzos para encontrar el modelo con mejor rendimiento. H2O es utilizado en todo el mundo por más de 18000 organizaciones y se conecta bien con R y Python para facilitar el desarrollo. Es una plataforma en memoria que proporciona un rendimiento excelente.

En este tutorial, primero aprenderá a instalar H2O en su máquina con las opciones Python y R. Entenderemos cómo usar esto en la línea de comandos para que comprenda su funcionamiento en línea. Si es un amante de Python, puede usar Jupyter o cualquier otro IDE de su elección para desarrollar aplicaciones H2O. Si prefiere R, puede usar RStudio para el desarrollo.

En este tutorial, consideraremos un ejemplo para comprender cómo trabajar con H2O. También aprenderemos cómo cambiar el algoritmo en el código de su programa y comparar su rendimiento con el anterior. El H2O también proporciona una herramienta basada en web para probar los diferentes algoritmos en su conjunto de datos. Esto se llama Flujo.

El tutorial le presentará el uso de Flow. Además, analizaremos el uso de AutoML que identificará el algoritmo de mejor rendimiento en su conjunto de datos. ¿No estás emocionado de aprender H2O? ¡Sigue leyendo!

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.

En la última lección, aprendió a crear modelos ML basados en H2O utilizando la interfaz de línea de comandos. H2O Flow cumple el mismo propósito, pero con una interfaz basada en web.

En las siguientes lecciones, le mostraré cómo iniciar H2O Flow y ejecutar una aplicación de muestra.

Inicio del flujo de H2O

La instalación de H2O que descargó anteriormente contiene el archivo h2o.jar. Para iniciar H2O Flow, primero ejecute este jar desde el símbolo del sistema:

$ java -jar h2o.jar

Cuando el jar se ejecute correctamente, aparecerá el siguiente mensaje en la consola:

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

Ahora, abra el navegador de su elección y escriba la URL anterior. Vería el escritorio basado en web H2O como se muestra aquí -

Este es básicamente un cuaderno similar a Colab o Jupyter. Le mostraré cómo cargar y ejecutar una aplicación de muestra en este cuaderno mientras le explicaré las distintas funciones de Flow. Haga clic en el enlace Ver flujos de ejemplo en la pantalla anterior para ver la lista de ejemplos proporcionados.

Describiré el ejemplo de Airlines delay Flow de la muestra.

Haga clic en el enlace Airlines Delay Flow en la lista de muestras como se muestra en la captura de pantalla a continuación:

Después de confirmar, se cargará el nuevo cuaderno.

Borrar todas las salidas

Antes de explicar las declaraciones de código en el cuaderno, borremos todas las salidas y luego ejecutemos el cuaderno gradualmente. Para borrar todas las salidas, seleccione la siguiente opción de menú:

Flow / Clear All Cell Contents

Esto se muestra en la siguiente captura de pantalla:

Una vez que se borran todas las salidas, ejecutaremos cada celda en el portátil individualmente y examinaremos su salida.

Ejecutando la primera celda

Haga clic en la primera celda. Aparece una bandera roja a la izquierda que indica que la celda está seleccionada. Esto es como se muestra en la captura de pantalla a continuación:

El contenido de esta celda es solo el comentario del programa escrito en lenguaje MarkDown (MD). El contenido describe lo que hace la aplicación cargada. Para ejecutar la celda, haga clic en el icono Ejecutar como se muestra en la captura de pantalla a continuación:

No verá ningún resultado debajo de la celda, ya que no hay un código ejecutable en la celda actual. El cursor ahora se mueve automáticamente a la siguiente celda, que está lista para ejecutarse.

Importación de datos

La siguiente celda contiene la siguiente declaración de Python:

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

La declaración importa el archivo allyears2k.csv de Amazon AWS al sistema. Cuando ejecuta la celda, importa el archivo y le da el siguiente resultado.

Configuración del analizador de datos

Ahora, necesitamos analizar los datos y adaptarlos a nuestro algoritmo ML. Esto se hace usando el siguiente comando:

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

Tras la ejecución de la declaración anterior, aparece un cuadro de diálogo de configuración de instalación. El cuadro de diálogo le permite varias configuraciones para analizar el archivo. Esto es como se muestra en la captura de pantalla a continuación:

En este cuadro de diálogo, puede seleccionar el analizador deseado de la lista desplegable dada y establecer otros parámetros, como el separador de campo, etc.

Análisis de datos

La siguiente declaración, que en realidad analiza el archivo de datos utilizando la configuración anterior, es larga y se muestra aquí:

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

Observe que los parámetros que ha configurado en el cuadro de configuración se enumeran en el código anterior. Ahora, ejecute esta celda. Después de un tiempo, el análisis se completa y verá el siguiente resultado:

Examinando el marco de datos

Después del procesamiento, genera un marco de datos, que se puede examinar utilizando la siguiente declaración:

getFrameSummary "allyears2k.hex"

Tras la ejecución de la declaración anterior, verá el siguiente resultado:

Ahora, sus datos están listos para ingresar en un algoritmo de aprendizaje automático.

La siguiente declaración es un comentario de programa que dice que usaremos el modelo de regresión y especifica la regularización preestablecida y los valores lambda.

Construyendo el modelo

A continuación, viene la declaración más importante y es la construcción del modelo en sí. Esto se especifica en la siguiente declaración:

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
}

Usamos glm, que es un conjunto de modelos lineales generalizados con el tipo de familia establecido en binomial. Puede ver estos resaltados en la declaración anterior. En nuestro caso, la salida esperada es binaria y es por eso que usamos el tipo binomial. Puede examinar los otros parámetros usted mismo; por ejemplo, mire alfa y lambda que habíamos especificado anteriormente. Consulte la documentación del modelo GLM para obtener una explicación de todos los parámetros.

Ahora, ejecute esta declaración. Tras la ejecución, se generará la siguiente salida:

Ciertamente, el tiempo de ejecución sería diferente en su máquina. Ahora, viene la parte más interesante de este código de muestra.

Examinar la salida

Simplemente generamos el modelo que hemos construido usando la siguiente declaración:

getModel "glm_model"

Tenga en cuenta que glm_model es el ID del modelo que especificamos como parámetro model_id al crear el modelo en la declaración anterior. Esto nos da una salida enorme que detalla los resultados con varios parámetros variables. En la captura de pantalla siguiente se muestra una salida parcial del informe:

Como puede ver en el resultado, dice que este es el resultado de ejecutar el algoritmo de modelado lineal generalizado en su conjunto de datos.

Justo encima del HISTORIAL DE PUNTUACIÓN, verá la etiqueta PARÁMETROS DEL MODELO, amplíela y verá la lista de todos los parámetros que se utilizan al crear el modelo. Esto se muestra en la captura de pantalla siguiente.

Asimismo, cada etiqueta proporciona una salida detallada de un tipo específico. Expanda las distintas etiquetas usted mismo para estudiar los resultados de diferentes tipos.

Construyendo otro modelo

A continuación, crearemos un modelo de aprendizaje profundo en nuestro marco de datos. La siguiente declaración en el código de muestra es solo un comentario de programa. La siguiente declaración es en realidad un comando de construcción de modelos. Es como se muestra aquí:

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
}

Como puede ver en el código anterior, especificamos el aprendizaje profundo para construir el modelo con varios parámetros establecidos en los valores apropiados como se especifica en la documentación del modelo de aprendizaje profundo. Cuando ejecute esta declaración, llevará más tiempo que la construcción del modelo GLM. Verá el siguiente resultado cuando se complete la construcción del modelo, aunque con diferentes tiempos.

Examinar la salida del modelo de aprendizaje profundo

Esto genera el tipo de salida, que se puede examinar utilizando la siguiente declaración como en el caso anterior.

getModel "deeplearning_model"

Consideraremos la salida de la curva ROC como se muestra a continuación para una referencia rápida.

Como en el caso anterior, expanda las distintas pestañas y estudie los diferentes resultados.

Guardar el modelo

Después de haber estudiado el resultado de diferentes modelos, decide utilizar uno de ellos en su entorno de producción. H20 le permite guardar este modelo como un POJO (Plain Old Java Object).

Expanda la última etiqueta PREVIEW POJO en la salida y verá el código Java para su modelo ajustado. Utilice esto en su entorno de producción.

A continuación, aprenderemos sobre una característica muy interesante de H2O. Aprenderemos a usar AutoML para probar y clasificar varios algoritmos en función de su rendimiento.

Para usar AutoML, inicie un nuevo cuaderno de Jupyter y siga los pasos que se muestran a continuación.

Importando AutoML

Primero importe el paquete H2O y AutoML al proyecto utilizando las siguientes dos declaraciones:

import h2o
from h2o.automl import H2OAutoML

Inicializar H2O

Inicialice h2o usando la siguiente declaración:

h2o.init()

Debería ver la información del clúster en la pantalla como se muestra en la captura de pantalla a continuación:

Cargando datos

Usaremos el mismo conjunto de datos iris.csv que usó anteriormente en este tutorial. Cargue los datos usando la siguiente declaración:

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

Preparando conjunto de datos

Necesitamos decidir sobre las características y las columnas de predicción. Usamos las mismas características y la columna de predicación que en nuestro caso anterior. Configure las características y la columna de salida utilizando las siguientes dos declaraciones:

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

Divida los datos en una proporción de 80:20 para entrenamiento y pruebas -

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

Aplicar AutoML

Ahora, estamos listos para aplicar AutoML en nuestro conjunto de datos. AutoML se ejecutará durante un período de tiempo fijo establecido por nosotros y nos dará el modelo optimizado. Configuramos AutoML usando la siguiente declaración:

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

El primer parámetro especifica el número de modelos que queremos evaluar y comparar.

El segundo parámetro especifica el tiempo durante el cual se ejecuta el algoritmo.

Ahora llamamos al método de tren en el objeto AutoML como se muestra aquí:

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

Especificamos la x como la matriz de características que creamos anteriormente, la y como la variable de salida para indicar el valor predicho y el marco de datos como train conjunto de datos.

Ejecute el código, tendrá que esperar 5 minutos (establecemos max_runtime_secs en 300) hasta que obtenga el siguiente resultado:

Imprimir la tabla de clasificación

Cuando se completa el procesamiento de AutoML, crea una tabla de clasificación que clasifica los 30 algoritmos que ha evaluado. Para ver los primeros 10 registros de la tabla de clasificación, use el siguiente código:

lb = aml.leaderboard
lb.head()

Tras la ejecución, el código anterior generará la siguiente salida:

Claramente, el algoritmo DeepLearning tiene la máxima puntuación.

Predicción sobre datos de prueba

Ahora que tiene los modelos clasificados, puede ver el rendimiento del modelo mejor calificado en sus datos de prueba. Para hacerlo, ejecute la siguiente declaración de código:

preds = aml.predict(test)

El procesamiento continúa por un tiempo y verá la siguiente salida cuando se complete.

Resultado de impresión

Imprima el resultado previsto usando la siguiente declaración:

print (preds)

Tras la ejecución de la declaración anterior, verá el siguiente resultado:

Imprimir la clasificación para todos

Si desea ver los rangos de todos los algoritmos probados, ejecute la siguiente declaración de código:

lb.head(rows = lb.nrows)

Tras la ejecución de la declaración anterior, se generará la siguiente salida (se muestra parcialmente):

Conclusión

H2O proporciona una plataforma de código abierto fácil de usar para aplicar diferentes algoritmos de ML en un conjunto de datos determinado. Proporciona varios algoritmos estadísticos y de aprendizaje automático, incluido el aprendizaje profundo. Durante la prueba, puede ajustar los parámetros a estos algoritmos. Puede hacerlo mediante la línea de comandos o la interfaz basada en web proporcionada llamada Flow. H2O también es compatible con AutoML que proporciona la clasificación entre varios algoritmos en función de su rendimiento. H2O también funciona bien en Big Data. Definitivamente, esto es una bendición para que Data Scientist aplique los diferentes modelos de aprendizaje automático en su conjunto de datos y elija el mejor para satisfacer sus necesidades.