H2O - Guia rápido

Você já foi convidado a desenvolver um modelo de aprendizado de máquina em um banco de dados enorme? Normalmente, o cliente fornecerá o banco de dados e solicitará que você faça algumas previsões, como quem serão os compradores em potencial; se pode haver uma detecção precoce de casos fraudulentos, etc. Para responder a essas perguntas, sua tarefa seria desenvolver um algoritmo de aprendizado de máquina que forneceria uma resposta à consulta do cliente. Desenvolver um algoritmo de aprendizado de máquina do zero não é uma tarefa fácil e por que você deve fazer isso quando há várias bibliotecas de aprendizado de máquina prontas para usar disponíveis no mercado.

Atualmente, você prefere usar essas bibliotecas, aplicar um algoritmo bem testado dessas bibliotecas e observar seu desempenho. Se o desempenho não estivesse dentro dos limites aceitáveis, você tentaria fazer o ajuste fino do algoritmo atual ou tentar um totalmente diferente.

Da mesma forma, você pode tentar vários algoritmos no mesmo conjunto de dados e, em seguida, escolher o melhor que atenda satisfatoriamente aos requisitos do cliente. É aqui que H2O vem em seu socorro. É uma estrutura de aprendizado de máquina de código aberto com implementações totalmente testadas de vários algoritmos de ML amplamente aceitos. Você apenas tem que pegar o algoritmo de seu enorme repositório e aplicá-lo ao seu conjunto de dados. Ele contém os algoritmos estatísticos e de ML mais amplamente usados.

Para mencionar alguns aqui, inclui máquinas com gradiente aumentado (GBM), modelo linear generalizado (GLM), aprendizado profundo e muito mais. Além disso, ele também oferece suporte à funcionalidade AutoML que classificará o desempenho de diferentes algoritmos em seu conjunto de dados, reduzindo assim seus esforços para encontrar o modelo de melhor desempenho. H2O é usado em todo o mundo por mais de 18.000 organizações e faz uma boa interface com R e Python para facilitar o desenvolvimento. É uma plataforma in-memory que oferece um desempenho excelente.

Neste tutorial, você aprenderá primeiro a instalar o H2O em sua máquina com as opções Python e R. Vamos entender como usar isso na linha de comando para que você entenda seu funcionamento em linha. Se você é um amante do Python, pode usar o Jupyter ou qualquer outro IDE de sua escolha para desenvolver aplicativos H2O. Se você preferir R, você pode usar RStudio para desenvolvimento.

Neste tutorial, consideraremos um exemplo para entender como trabalhar com H2O. Também aprenderemos como alterar o algoritmo no código do programa e comparar seu desempenho com o anterior. O H2O também fornece uma ferramenta baseada na web para testar os diferentes algoritmos em seu conjunto de dados. Isso é chamado de fluxo.

O tutorial irá apresentá-lo ao uso do Flow. Paralelamente, discutiremos o uso do AutoML que identificará o algoritmo de melhor desempenho em seu conjunto de dados. Você não está animado para aprender H2O? Continue lendo!

H2O pode ser configurado e usado com cinco opções diferentes, conforme listado abaixo -

Instalar em Python
Instalar em R
GUI de fluxo baseado na web
Hadoop
Nuvem Anaconda

Em nossas seções subsequentes, você verá as instruções para instalação de H2O com base nas opções disponíveis. É provável que você use uma das opções.

Instalar em Python

Para executar H2O com Python, a instalação requer várias dependências. Portanto, vamos começar a instalar o conjunto mínimo de dependências para executar H2O.

Instalando Dependências

Para instalar uma dependência, execute o seguinte comando pip -

$ pip install requests

Abra a janela do console e digite o comando acima para instalar o pacote de solicitações. A imagem a seguir mostra a execução do comando acima em nossa máquina Mac -

Depois de instalar os pedidos, você precisa instalar mais três pacotes, conforme mostrado abaixo -

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

A lista mais atualizada de dependências está disponível na página H2O GitHub. No momento em que este livro foi escrito, as seguintes dependências estão listadas na página.

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

Removendo versões anteriores

Depois de instalar as dependências acima, você precisa remover qualquer instalação H2O existente. Para fazer isso, execute o seguinte comando -

$ pip uninstall h2o

Instalando a versão mais recente

Agora, vamos instalar a versão mais recente do H2O usando o seguinte comando -

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

Após a instalação bem-sucedida, você deverá ver a seguinte mensagem exibida na tela -

Installing collected packages: h2o
Successfully installed h2o-3.26.0.1

Testando a instalação

Para testar a instalação, executaremos um dos aplicativos de amostra fornecidos na instalação do H2O. Primeiro, inicie o prompt do Python digitando o seguinte comando -

$ Python3

Assim que o interpretador Python for iniciado, digite a seguinte instrução Python no prompt de comando Python -

>>>import h2o

O comando acima importa o pacote H2O em seu programa. Em seguida, inicialize o sistema H2O usando o seguinte comando -

>>>h2o.init()

Sua tela mostraria as informações do cluster e deveria olhar o seguinte nesta fase -

Agora, você está pronto para executar o código de amostra. Digite o seguinte comando no prompt do Python e execute-o.

>>>h2o.demo("glm")

A demonstração consiste em um bloco de notas Python com uma série de comandos. Após a execução de cada comando, sua saída é exibida imediatamente na tela e você deverá pressionar a tecla para continuar com a próxima etapa. A captura de tela parcial sobre a execução da última instrução no bloco de notas é mostrada aqui -

Neste estágio, a instalação do Python está completa e você está pronto para sua própria experimentação.

Instalar em R

Instalar H2O para desenvolvimento R é muito semelhante a instalá-lo para Python, exceto que você usaria o prompt R para a instalação.

Iniciando R Console

Inicie o console R clicando no ícone do aplicativo R em sua máquina. A tela do console seria exibida conforme mostrado na imagem a seguir -

A instalação do H2O seria feita no prompt R acima. Se você preferir usar o RStudio, digite os comandos na subjanela do console R.

Removendo versões anteriores

Para começar, remova as versões mais antigas usando o seguinte comando no prompt R -

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

Baixando Dependências

Baixe as dependências para H2O usando o seguinte código -

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

Instalando H2O

Instale H2O digitando o seguinte comando no prompt R -

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

A captura de tela a seguir mostra a saída esperada -

Existe outra forma de instalar H2O em R.

Instale em R a partir do CRAN

Para instalar R a partir do CRAN, use o seguinte comando no prompt R -

> install.packages("h2o")

Você será solicitado a selecionar o espelho -

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

Uma caixa de diálogo exibindo a lista de sites espelho é mostrada em sua tela. Selecione o local mais próximo ou o espelho de sua escolha.

Instalação de teste

No prompt R, digite e execute o seguinte código -

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

A saída gerada será conforme mostrado na imagem a seguir -

Sua instalação H2O em R está concluída agora.

Instalando o Web GUI Flow

Para instalar o GUI Flow, baixe o arquivo de instalação do site H20. Descompacte o arquivo baixado em sua pasta preferida. Observe a presença do arquivo h2o.jar na instalação. Execute este arquivo em uma janela de comando usando o seguinte comando -

$ java -jar h2o.jar

Depois de um tempo, o seguinte aparecerá na janela do 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:

Para iniciar o fluxo, abra o URL fornecido http://localhost:54321no seu navegador. A seguinte tela irá aparecer -

Nesse estágio, a instalação do Flow está concluída.

Instalar na nuvem Hadoop / Anaconda

A menos que você seja um desenvolvedor experiente, você não pensaria em usar H2O em Big Data. É suficiente dizer aqui que os modelos H2O são executados com eficiência em enormes bancos de dados de vários terabytes. Se seus dados estiverem na instalação do Hadoop ou na nuvem, siga as etapas fornecidas no site H2O para instalá-lo em seu respectivo banco de dados.

Agora que instalou e testou o H2O com sucesso em sua máquina, você está pronto para o desenvolvimento real. Primeiro, veremos o desenvolvimento em um prompt de comando. Em nossas lições subsequentes, aprenderemos como fazer testes de modelo em H2O Flow.

Desenvolvendo em Prompt de Comando

Vamos agora considerar o uso de H2O para classificar plantas do conhecido conjunto de dados da íris que está disponível gratuitamente para o desenvolvimento de aplicativos de aprendizado de máquina.

Inicie o interpretador Python digitando o seguinte comando na janela do shell -

$ Python3

Isso inicia o interpretador Python. Importe a plataforma h2o usando o seguinte comando -

>>> import h2o

Usaremos o algoritmo Random Forest para classificação. Isso é fornecido no pacote H2ORandomForestEstimator. Importamos este pacote usando a instrução import da seguinte maneira -

>>> from h2o.estimators import H2ORandomForestEstimator

Inicializamos o ambiente H2o chamando seu método init.

>>> h2o.init()

Na inicialização bem-sucedida, você deve ver a seguinte mensagem no console junto com as informações do cluster.

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

Agora, vamos importar os dados da íris usando o método import_file em H2O.

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

O progresso será exibido conforme mostrado na imagem a seguir -

Depois que o arquivo é carregado na memória, você pode verificar isso exibindo as primeiras 10 linhas da tabela carregada. Você usa ohead método para fazer isso -

>>> data.head()

Você verá a seguinte saída em formato tabular.

A tabela também exibe os nomes das colunas. Usaremos as primeiras quatro colunas como recursos para nosso algoritmo de ML e a última classe de coluna como saída prevista. Especificamos isso na chamada ao nosso algoritmo de ML, criando primeiro as duas variáveis a seguir.

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

Em seguida, dividimos os dados em treinamento e teste chamando o método split_frame.

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

Os dados são divididos na proporção 80:20. Usamos 80% de dados para treinamento e 20% para teste.

Agora, carregamos o modelo Random Forest integrado no sistema.

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

Na chamada acima, definimos o número de árvores em 50, a profundidade máxima da árvore em 20 e o número de dobras para validação cruzada em 10. Agora precisamos treinar o modelo. Fazemos isso chamando o método train da seguinte maneira -

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

O método train recebe os recursos e a saída que criamos anteriormente como os dois primeiros parâmetros. O conjunto de dados de treinamento está definido para treinar, o que representa 80% de nosso conjunto de dados completo. Durante o treinamento, você verá o progresso conforme mostrado aqui -

Agora, com o processo de construção do modelo concluído, é hora de testar o modelo. Fazemos isso chamando o método model_performance no objeto de modelo treinado.

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

Na chamada do método acima, enviamos dados de teste como nosso parâmetro.

É hora de ver o resultado, que é o desempenho de nosso modelo. Você pode fazer isso simplesmente imprimindo a performance.

>>> print (performance)

Isso lhe dará a seguinte saída -

A saída mostra o erro quadrático médio (MSE), erro quadrático médio (RMSE), LogLoss e até mesmo a matriz de confusão.

Correndo em Jupyter

Vimos a execução do comando e também entendemos a finalidade de cada linha de código. Você pode executar o código inteiro em um ambiente Jupyter, linha por linha ou o programa inteiro de uma vez. A lista completa é fornecida aqui -

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)

Execute o código e observe a saída. Agora você pode apreciar como é fácil aplicar e testar um algoritmo de floresta aleatória em seu conjunto de dados. A potência do H20 vai muito além dessa capacidade. E se você quiser tentar outro modelo no mesmo conjunto de dados para ver se consegue um melhor desempenho. Isso é explicado em nossa seção subsequente.

Aplicando um Algoritmo Diferente

Agora, aprenderemos como aplicar um algoritmo Gradient Boosting ao nosso conjunto de dados anterior para ver como ele funciona. Na lista completa acima, você precisará fazer apenas duas pequenas alterações, conforme destacado no código abaixo -

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)

Execute o código e você obterá a seguinte saída -

Basta comparar os resultados como MSE, RMSE, Matriz de confusão, etc. com a saída anterior e decidir qual usar para implantação de produção. Na verdade, você pode aplicar vários algoritmos diferentes para decidir sobre o melhor que atenda ao seu propósito.

Na última lição, você aprendeu a criar modelos de ML baseados em H2O usando a interface de linha de comando. H2O Flow cumpre o mesmo propósito, mas com uma interface baseada na web.

Nas próximas lições, mostrarei como iniciar o H2O Flow e executar um aplicativo de amostra.

Fluxo de H2O inicial

A instalação H2O que você baixou anteriormente contém o arquivo h2o.jar. Para iniciar o fluxo de H2O, primeiro execute este jar no prompt de comando -

$ java -jar h2o.jar

Quando o jar for executado com sucesso, você receberá a seguinte mensagem no console -

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

Agora, abra o navegador de sua escolha e digite a URL acima. Você veria a área de trabalho baseada na web H2O conforme mostrado aqui -

Este é basicamente um notebook semelhante ao Colab ou Jupyter. Vou mostrar como carregar e executar um aplicativo de amostra neste bloco de notas enquanto explicarei os vários recursos do Flow. Clique no link ver exemplos de fluxos na tela acima para ver a lista de exemplos fornecidos.

Descreverei o exemplo de Fluxo de atraso das companhias aéreas da amostra.

Clique no link Fluxo de Atraso das Companhias Aéreas na lista de amostras, conforme mostrado na imagem abaixo -

Depois de confirmar, o novo bloco de notas será carregado.

Limpando todas as saídas

Antes de explicarmos as instruções de código no notebook, vamos limpar todas as saídas e, em seguida, executar o notebook gradualmente. Para limpar todas as saídas, selecione a seguinte opção de menu -

Flow / Clear All Cell Contents

Isso é mostrado na imagem a seguir -

Assim que todas as saídas forem apagadas, executaremos cada célula do notebook individualmente e examinaremos sua saída.

Executando a primeira célula

Clique na primeira célula. Uma bandeira vermelha aparece à esquerda indicando que a célula está selecionada. Isso é mostrado na imagem abaixo -

O conteúdo desta célula é apenas o comentário do programa escrito na linguagem MarkDown (MD). O conteúdo descreve o que o aplicativo carregado faz. Para executar a célula, clique no ícone Executar conforme mostrado na imagem abaixo -

Você não verá nenhuma saída abaixo da célula, pois não há código executável na célula atual. O cursor agora se move automaticamente para a próxima célula, que está pronta para ser executada.

Importando Dados

A próxima célula contém a seguinte instrução Python -

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

A declaração importa o arquivo allyears2k.csv do Amazon AWS para o sistema. Quando você executa a célula, ela importa o arquivo e fornece a seguinte saída.

Configurando o analisador de dados

Agora, precisamos analisar os dados e torná-los adequados para nosso algoritmo de ML. Isso é feito usando o seguinte comando -

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

Após a execução da instrução acima, uma caixa de diálogo de configuração de instalação é exibida. A caixa de diálogo permite várias configurações para analisar o arquivo. Isso é mostrado na imagem abaixo -

Nesta caixa de diálogo, você pode selecionar o analisador desejado na lista suspensa fornecida e definir outros parâmetros, como o separador de campo, etc.

Análise de dados

A próxima instrução, que realmente analisa o arquivo de dados usando a configuração acima, é longa e é mostrada aqui -

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 os parâmetros que você configurou na caixa de configuração estão listados no código acima. Agora, execute esta célula. Depois de um tempo, a análise é concluída e você verá a seguinte saída -

Examinando Dataframe

Após o processamento, ele gera um dataframe, que pode ser examinado usando a seguinte instrução -

getFrameSummary "allyears2k.hex"

Após a execução da instrução acima, você verá a seguinte saída -

Agora, seus dados estão prontos para serem alimentados em um algoritmo de aprendizado de máquina.

A próxima declaração é um comentário do programa que diz que usaremos o modelo de regressão e especifica a regularização predefinida e os valores lambda.

Construindo o modelo

A seguir, vem a afirmação mais importante, que é construir o próprio modelo. Isso é especificado na seguinte declaração -

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 é um conjunto de modelo linear generalizado com tipo de família definido como binomial. Você pode ver isso destacado na declaração acima. No nosso caso, a saída esperada é binária e é por isso que usamos o tipo binomial. Você pode examinar os outros parâmetros sozinho; por exemplo, observe alfa e lambda que especificamos anteriormente. Consulte a documentação do modelo GLM para obter a explicação de todos os parâmetros.

Agora, execute esta declaração. Após a execução, a seguinte saída será gerada -

Certamente, o tempo de execução seria diferente em sua máquina. Agora, vem a parte mais interessante deste código de amostra.

Análise de saída

Simplesmente produzimos o modelo que construímos usando a seguinte instrução -

getModel "glm_model"

Observe que glm_model é o ID do modelo que especificamos como parâmetro model_id ao construir o modelo na instrução anterior. Isso nos dá uma grande saída detalhando os resultados com vários parâmetros variáveis. Uma saída parcial do relatório é mostrada na captura de tela abaixo -

Como você pode ver na saída, diz que este é o resultado da execução do algoritmo de Modelagem Linear Generalizada em seu conjunto de dados.

Logo acima do HISTÓRICO DE PONTUAÇÃO, você verá a tag MODEL PARAMETERS, expanda-a e verá a lista de todos os parâmetros que são usados durante a construção do modelo. Isso é mostrado na imagem abaixo.

Da mesma forma, cada tag fornece uma saída detalhada de um tipo específico. Expanda as várias tags você mesmo para estudar os resultados de diferentes tipos.

Construindo outro modelo

A seguir, construiremos um modelo de Deep Learning em nosso dataframe. A próxima instrução no código de amostra é apenas um comentário do programa. A declaração a seguir é na verdade um comando de construção de modelo. É como mostrado aqui -

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 você pode ver no código acima, especificamos deeplearning para construir o modelo com vários parâmetros definidos para os valores apropriados, conforme especificado na documentação do modelo de deeplearning. Quando você executa esta instrução, levará mais tempo do que a construção do modelo do GLM. Você verá a seguinte saída quando a construção do modelo for concluída, embora com tempos diferentes.

Examinando a saída do modelo de aprendizado profundo

Isso gera o tipo de saída, que pode ser examinada usando a instrução a seguir, como no caso anterior.

getModel "deeplearning_model"

Consideraremos a saída da curva ROC conforme mostrado abaixo para referência rápida.

Como no caso anterior, expanda as várias guias e estude os diferentes resultados.

Salvando o modelo

Depois de estudar a saída de diferentes modelos, você decide usar um deles em seu ambiente de produção. H20 permite que você salve este modelo como um POJO (Plain Old Java Object).

Expanda a última tag PREVIEW POJO na saída e você verá o código Java para seu modelo ajustado. Use isso em seu ambiente de produção.

A seguir, aprenderemos sobre um recurso muito interessante do H2O. Aprenderemos como usar o AutoML para testar e classificar vários algoritmos com base em seu desempenho.

Para usar o AutoML, inicie um novo bloco de notas Jupyter e siga as etapas mostradas abaixo.

Importando AutoML

Primeiro importe H2O e pacote AutoML para o projeto usando as duas instruções a seguir -

import h2o
from h2o.automl import H2OAutoML

Inicializar H2O

Inicialize o H2o usando a seguinte instrução -

h2o.init()

Você deve ver as informações do cluster na tela, conforme mostrado na captura de tela abaixo -

Carregando dados

Usaremos o mesmo conjunto de dados iris.csv que você usou anteriormente neste tutorial. Carregue os dados usando a seguinte instrução -

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

Preparando o conjunto de dados

Precisamos decidir sobre os recursos e as colunas de previsão. Usamos os mesmos recursos e a coluna de predicação de nosso caso anterior. Defina os recursos e a coluna de saída usando as duas instruções a seguir -

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

Divida os dados na proporção de 80:20 para treinamento e teste -

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

Aplicando AutoML

Agora, estamos prontos para aplicar o AutoML em nosso conjunto de dados. O AutoML será executado por um período de tempo fixo definido por nós e nos fornecerá o modelo otimizado. Configuramos o AutoML usando a seguinte instrução -

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

O primeiro parâmetro especifica o número de modelos que queremos avaliar e comparar.

O segundo parâmetro especifica o tempo de execução do algoritmo.

Agora chamamos o método train no objeto AutoML conforme mostrado aqui -

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

Especificamos x como a matriz de recursos que criamos anteriormente, y como a variável de saída para indicar o valor previsto e o dataframe como train conjunto de dados.

Execute o código, você terá que esperar 5 minutos (definimos o max_runtime_secs para 300) até obter a seguinte saída -

Imprimindo o placar

Quando o processamento do AutoML é concluído, ele cria um placar classificando todos os 30 algoritmos avaliados. Para ver os primeiros 10 registros da tabela de classificação, use o seguinte código -

lb = aml.leaderboard
lb.head()

Após a execução, o código acima irá gerar a seguinte saída -

Claramente, o algoritmo DeepLearning obteve a pontuação máxima.

Previsão de dados de teste

Agora que você classificou os modelos, pode ver o desempenho do modelo com melhor classificação em seus dados de teste. Para fazer isso, execute a seguinte instrução de código -

preds = aml.predict(test)

O processamento continua por um tempo e você verá a seguinte saída quando for concluído.

Resultado da Impressão

Imprima o resultado previsto usando a seguinte declaração -

print (preds)

Após a execução da instrução acima, você verá o seguinte resultado -

Imprimindo a classificação para todos

Se você quiser ver as classificações de todos os algoritmos testados, execute a seguinte instrução de código -

lb.head(rows = lb.nrows)

Após a execução da instrução acima, a seguinte saída será gerada (parcialmente mostrada) -

Conclusão

H2O fornece uma plataforma de código aberto fácil de usar para aplicar diferentes algoritmos de ML em um determinado conjunto de dados. Ele fornece vários algoritmos estatísticos e de ML, incluindo aprendizado profundo. Durante o teste, você pode ajustar os parâmetros desses algoritmos. Você pode fazer isso usando a linha de comando ou a interface baseada na web fornecida chamada Flow. H2O também oferece suporte a AutoML, que fornece a classificação entre os vários algoritmos com base em seu desempenho. H2O também tem um bom desempenho em Big Data. Definitivamente, é uma vantagem para o cientista de dados aplicar os diferentes modelos de aprendizado de máquina em seu conjunto de dados e escolher o melhor para atender às suas necessidades.