H2O - Instalação

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.