H2O - Guida rapida

Ti è mai stato chiesto di sviluppare un modello di Machine Learning su un enorme database? In genere, il cliente ti fornirà il database e ti chiederà di fare alcune previsioni come chi saranno i potenziali acquirenti; se è possibile rilevare tempestivamente casi fraudolenti, ecc. Per rispondere a queste domande, il tuo compito sarebbe sviluppare un algoritmo di Machine Learning che fornisca una risposta alla domanda del cliente. Sviluppare un algoritmo di Machine Learning da zero non è un compito facile e perché dovresti farlo quando sul mercato sono disponibili diverse librerie di Machine Learning pronte per l'uso.

Oggigiorno, preferiresti usare queste librerie, applicare un algoritmo ben collaudato da queste librerie e guardare le sue prestazioni. Se le prestazioni non fossero entro limiti accettabili, proveresti a mettere a punto l'algoritmo corrente o provarne uno completamente diverso.

Allo stesso modo, è possibile provare più algoritmi sullo stesso set di dati e quindi scegliere quello migliore che soddisfi i requisiti del cliente. È qui che H2O viene in tuo soccorso. È un framework di machine learning open source con implementazioni completamente testate di diversi algoritmi ML ampiamente accettati. Devi solo prendere l'algoritmo dal suo enorme repository e applicarlo al tuo set di dati. Contiene gli algoritmi statistici e ML più utilizzati.

Per citarne alcuni qui include macchine con aumento del gradiente (GBM), modello lineare generalizzato (GLM), apprendimento profondo e molti altri. Non solo supporta anche la funzionalità AutoML che classificherà le prestazioni di diversi algoritmi sul set di dati, riducendo così i tuoi sforzi per trovare il modello con le migliori prestazioni. H2O è utilizzato in tutto il mondo da più di 18000 organizzazioni e si interfaccia bene con R e Python per facilitare lo sviluppo. È una piattaforma in-memory che fornisce prestazioni eccezionali.

In questo tutorial, imparerai prima a installare H2O sulla tua macchina con entrambe le opzioni Python e R. Capiremo come usarlo nella riga di comando in modo da comprenderne il funzionamento a livello di riga. Se sei un amante di Python, puoi usare Jupyter o qualsiasi altro IDE di tua scelta per lo sviluppo di applicazioni H2O. Se preferisci R, puoi usare RStudio per lo sviluppo.

In questo tutorial, considereremo un esempio per capire come lavorare con H2O. Impareremo anche come modificare l'algoritmo nel codice del tuo programma e confrontare le sue prestazioni con quello precedente. H2O fornisce anche uno strumento basato sul web per testare i diversi algoritmi sul tuo set di dati. Questo si chiama Flow.

Il tutorial ti introdurrà all'uso di Flow. Parallelamente, discuteremo dell'uso di AutoML che identificherà l'algoritmo con le migliori prestazioni nel tuo set di dati. Non sei entusiasta di imparare H2O? Continua a leggere!

H2O può essere configurato e utilizzato con cinque diverse opzioni come elencato di seguito:

Installa in Python
Installa in R
GUI di flusso basata sul Web
Hadoop
Anaconda Cloud

Nelle nostre sezioni successive, vedrai le istruzioni per l'installazione di H2O in base alle opzioni disponibili. È probabile che tu utilizzi una delle opzioni.

Installa in Python

Per eseguire H2O con Python, l'installazione richiede diverse dipendenze. Quindi iniziamo a installare il set minimo di dipendenze per eseguire H2O.

Installazione delle dipendenze

Per installare una dipendenza, esegui il seguente comando pip:

$ pip install requests

Apri la finestra della console e digita il comando precedente per installare il pacchetto delle richieste. La seguente schermata mostra l'esecuzione del comando precedente sulla nostra macchina Mac -

Dopo aver installato le richieste, è necessario installare altri tre pacchetti come mostrato di seguito:

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

L'elenco più aggiornato delle dipendenze è disponibile sulla pagina H2O GitHub. Al momento della stesura di questo documento, le seguenti dipendenze sono elencate nella pagina.

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

Rimozione di versioni precedenti

Dopo aver installato le dipendenze di cui sopra, è necessario rimuovere qualsiasi installazione H2O esistente. Per fare ciò, esegui il seguente comando:

$ pip uninstall h2o

Installazione della versione più recente

Ora, installiamo l'ultima versione di H2O usando il seguente comando:

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

Al termine dell'installazione, sullo schermo dovrebbe essere visualizzato il seguente messaggio:

Installing collected packages: h2o
Successfully installed h2o-3.26.0.1

Verifica dell'installazione

Per testare l'installazione, eseguiremo una delle applicazioni di esempio fornite nell'installazione H2O. Per prima cosa avvia il prompt di Python digitando il seguente comando:

$ Python3

Una volta avviato l'interprete Python, digita la seguente istruzione Python sul prompt dei comandi Python:

>>>import h2o

Il comando precedente importa il pacchetto H2O nel tuo programma. Successivamente, inizializza il sistema H2O utilizzando il seguente comando:

>>>h2o.init()

Lo schermo mostrerebbe le informazioni sul cluster e dovrebbe apparire quanto segue in questa fase:

Ora sei pronto per eseguire il codice di esempio. Digita il seguente comando nel prompt di Python ed eseguilo.

>>>h2o.demo("glm")

La demo consiste in un notebook Python con una serie di comandi. Dopo aver eseguito ogni comando, il suo output viene mostrato immediatamente sullo schermo e ti verrà chiesto di premere il tasto per continuare con il passaggio successivo. Lo screenshot parziale sull'esecuzione dell'ultima istruzione nel notebook è mostrato qui -

A questo punto l'installazione di Python è completa e sei pronto per la tua sperimentazione.

Installa in R

L'installazione di H2O per lo sviluppo R è molto simile all'installazione per Python, tranne per il fatto che useresti il prompt R per l'installazione.

Avvio di R Console

Avvia la console R facendo clic sull'icona dell'applicazione R sulla macchina. La schermata della console apparirà come mostrato nella seguente schermata:

La tua installazione H2O verrebbe eseguita al prompt R. sopra. Se preferisci usare RStudio, digita i comandi nella sottofinestra della console R.

Rimozione di versioni precedenti

Per cominciare, rimuovi le versioni precedenti utilizzando il seguente comando nel prompt R:

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

Download delle dipendenze

Scarica le dipendenze per H2O utilizzando il codice seguente:

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

Installazione di H2O

Installa H2O digitando il seguente comando al prompt R:

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

Lo screenshot seguente mostra l'output previsto:

C'è un altro modo per installare H2O in R.

Installa in R da CRAN

Per installare R da CRAN, utilizzare il seguente comando sul prompt R:

> install.packages("h2o")

Ti verrà chiesto di selezionare lo specchio -

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

Sullo schermo viene visualizzata una finestra di dialogo che mostra l'elenco dei siti mirror. Seleziona la posizione più vicina o lo specchio di tua scelta.

Installazione di prova

Al prompt R, digita ed esegui il codice seguente:

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

L'output generato sarà come mostrato nello screenshot seguente:

La tua installazione H2O in R è ora completa.

Installazione di Web GUI Flow

Per installare GUI Flow scaricare il file di installazione dal sito H20. Decomprimere il file scaricato nella cartella preferita. Notare la presenza del file h2o.jar nell'installazione. Esegui questo file in una finestra di comando utilizzando il seguente comando:

$ java -jar h2o.jar

Dopo un po ', nella finestra della console verrà visualizzato quanto segue.

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:

Per avviare il flusso, apri l'URL fornito http://localhost:54321nel tuo browser. Apparirà la seguente schermata:

In questa fase, l'installazione di Flow è completa.

Installa su Hadoop / Anaconda Cloud

A meno che tu non sia uno sviluppatore esperto, non penseresti di utilizzare H2O su Big Data. È sufficiente dire qui che i modelli H2O funzionano in modo efficiente su enormi database di diversi terabyte. Se i tuoi dati si trovano sulla tua installazione di Hadoop o nel Cloud, segui i passaggi indicati sul sito H2O per installarli per il tuo rispettivo database.

Ora che hai installato e testato con successo H2O sulla tua macchina, sei pronto per lo sviluppo reale. Per prima cosa, vedremo lo sviluppo da un prompt dei comandi. Nelle nostre lezioni successive, impareremo come eseguire il test del modello in H2O Flow.

Sviluppo nel prompt dei comandi

Consideriamo ora l'utilizzo di H2O per classificare le piante del noto set di dati iris che è disponibile gratuitamente per lo sviluppo di applicazioni di Machine Learning.

Avvia l'interprete Python digitando il seguente comando nella finestra della shell:

$ Python3

Questo avvia l'interprete Python. Importa la piattaforma h2o utilizzando il seguente comando:

>>> import h2o

Useremo l'algoritmo Random Forest per la classificazione. Questo è fornito nel pacchetto H2ORandomForestEstimator. Importiamo questo pacchetto utilizzando l'istruzione import come segue:

>>> from h2o.estimators import H2ORandomForestEstimator

Inizializziamo l'ambiente H2o chiamando il suo metodo init.

>>> h2o.init()

Se l'inizializzazione è riuscita, dovresti vedere il seguente messaggio sulla console insieme alle informazioni sul cluster.

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

Ora, importeremo i dati dell'iride utilizzando il metodo import_file in H2O.

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

Lo stato di avanzamento verrà visualizzato come mostrato nella seguente schermata:

Dopo che il file è stato caricato in memoria, è possibile verificarlo visualizzando le prime 10 righe della tabella caricata. Usi il filehead metodo per farlo -

>>> data.head()

Vedrai il seguente output in formato tabulare.

La tabella mostra anche i nomi delle colonne. Useremo le prime quattro colonne come caratteristiche per il nostro algoritmo ML e l'ultima classe di colonna come output previsto. Lo specifichiamo nella chiamata al nostro algoritmo ML creando prima le seguenti due variabili.

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

Successivamente, suddividiamo i dati in training e test chiamando il metodo split_frame.

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

I dati sono suddivisi nel rapporto 80:20. Usiamo l'80% dei dati per la formazione e il 20% per i test.

Ora, carichiamo il modello Random Forest integrato nel sistema.

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

Nella chiamata precedente, abbiamo impostato il numero di alberi a 50, la profondità massima dell'albero a 20 e il numero di pieghe per la convalida incrociata a 10. Ora dobbiamo addestrare il modello. Lo facciamo chiamando il metodo train come segue:

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

Il metodo train riceve le caratteristiche e l'output che abbiamo creato in precedenza come primi due parametri. Il set di dati di addestramento è impostato per il training, ovvero l'80% del nostro set di dati completo. Durante l'allenamento, vedrai i progressi come mostrato qui -

Ora, poiché il processo di creazione del modello è terminato, è tempo di testare il modello. Lo facciamo chiamando il metodo model_performance sull'oggetto del modello addestrato.

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

Nella chiamata al metodo sopra, abbiamo inviato i dati di test come nostro parametro.

È giunto il momento di vedere l'output, ovvero le prestazioni del nostro modello. Puoi farlo semplicemente stampando la performance.

>>> print (performance)

Questo ti darà il seguente output:

L'output mostra Mean Square Error (MSE), Root Mean Square Error (RMSE), LogLoss e persino Confusion Matrix.

In esecuzione in Jupyter

Abbiamo visto l'esecuzione dal comando e compreso lo scopo di ogni riga di codice. È possibile eseguire l'intero codice in un ambiente Jupyter, riga per riga o l'intero programma alla volta. L'elenco completo è fornito qui -

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)

Eseguire il codice e osservare l'output. Ora puoi apprezzare quanto sia facile applicare e testare un algoritmo di foresta casuale sul tuo set di dati. La potenza dell'H20 va ben oltre questa capacità. E se volessi provare un altro modello sullo stesso set di dati per vedere se puoi ottenere prestazioni migliori. Questo è spiegato nella nostra sezione successiva.

Applicazione di un algoritmo diverso

Ora impareremo come applicare un algoritmo di aumento del gradiente al nostro set di dati precedente per vedere come si comporta. Nell'elenco completo sopra, dovrai apportare solo due piccole modifiche come evidenziato nel codice sottostante -

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)

Esegui il codice e otterrai il seguente output:

Basta confrontare i risultati come MSE, RMSE, Confusion Matrix, ecc. Con l'output precedente e decidere quale utilizzare per la distribuzione in produzione. È un dato di fatto, puoi applicare diversi algoritmi diversi per decidere quello migliore che soddisfa il tuo scopo.

Nell'ultima lezione hai imparato a creare modelli ML basati su H2O utilizzando l'interfaccia a riga di comando. H2O Flow soddisfa lo stesso scopo, ma con un'interfaccia basata sul web.

Nelle lezioni seguenti, ti mostrerò come avviare H2O Flow ed eseguire un'applicazione di esempio.

Avvio del flusso H2O

L'installazione H2O che hai scaricato in precedenza contiene il file h2o.jar. Per avviare H2O Flow, esegui prima questo jar dal prompt dei comandi -

$ java -jar h2o.jar

Quando il jar viene eseguito correttamente, riceverai il seguente messaggio sulla console:

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

Ora apri il browser di tua scelta e digita l'URL sopra. Vedresti il desktop basato sul web H2O come mostrato qui -

Questo è fondamentalmente un notebook simile a Colab o Jupyter. Ti mostrerò come caricare ed eseguire un'applicazione di esempio in questo notebook mentre spiegherò le varie funzionalità di Flow. Fare clic sul collegamento Visualizza flussi di esempio nella schermata precedente per visualizzare l'elenco degli esempi forniti.

Descriverò l'esempio del flusso di ritardo delle compagnie aeree dal campione.

Fare clic sul collegamento Flusso di ritardo delle compagnie aeree nell'elenco dei campioni come mostrato nello screenshot qui sotto -

Dopo aver confermato, verrà caricato il nuovo notebook.

Cancellazione di tutte le uscite

Prima di spiegare le istruzioni del codice nel notebook, cancelliamo tutti gli output e quindi eseguiamo il notebook gradualmente. Per cancellare tutte le uscite, selezionare la seguente opzione di menu:

Flow / Clear All Cell Contents

Questo è mostrato nella seguente schermata:

Una volta cancellati tutti gli output, eseguiremo singolarmente ciascuna cella del notebook e ne esamineremo l'output.

Esecuzione della prima cella

Fare clic sulla prima cella. Viene visualizzata una bandiera rossa a sinistra che indica che la cella è selezionata. Questo è come mostrato nello screenshot qui sotto -

Il contenuto di questa cella è solo il commento del programma scritto in linguaggio MarkDown (MD). Il contenuto descrive ciò che fa l'applicazione caricata. Per eseguire la cella, fare clic sull'icona Esegui come mostrato nello screenshot qui sotto -

Non vedrai alcun output sotto la cella poiché non c'è codice eseguibile nella cella corrente. Il cursore ora si sposta automaticamente alla cella successiva, che è pronta per essere eseguita.

Importazione di dati

La cella successiva contiene la seguente istruzione Python:

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

L'istruzione importa il file allyears2k.csv da Amazon AWS nel sistema. Quando esegui la cella, importa il file e ti dà il seguente output.

Configurazione del parser dei dati

Ora, dobbiamo analizzare i dati e renderli adatti al nostro algoritmo ML. Questo viene fatto usando il seguente comando:

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

All'esecuzione dell'istruzione precedente, viene visualizzata una finestra di dialogo di configurazione dell'installazione. La finestra di dialogo consente diverse impostazioni per l'analisi del file. Questo è come mostrato nello screenshot qui sotto -

In questa finestra di dialogo, è possibile selezionare il parser desiderato dall'elenco a discesa fornito e impostare altri parametri come il separatore di campo, ecc.

Analisi dei dati

L'istruzione successiva, che in realtà analizza il file di dati utilizzando la configurazione precedente, è lunga ed è come mostrato qui -

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

Osserva che i parametri che hai impostato nella casella di configurazione sono elencati nel codice sopra. Ora, avvia questa cella. Dopo un po ', l'analisi viene completata e vedrai il seguente output:

Esame del dataframe

Dopo l'elaborazione, genera un dataframe, che può essere esaminato utilizzando la seguente dichiarazione:

getFrameSummary "allyears2k.hex"

Dopo l'esecuzione dell'istruzione precedente, vedrai il seguente output:

Ora i tuoi dati sono pronti per essere inseriti in un algoritmo di Machine Learning.

L'istruzione successiva è un commento del programma che dice che utilizzeremo il modello di regressione e specifica la regolarizzazione preimpostata ei valori lambda.

Costruire il modello

Poi arriva l'affermazione più importante e cioè la costruzione del modello stesso. Ciò è specificato nella seguente dichiarazione:

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
}

Usiamo glm, che è una suite di modelli lineari generalizzati con il tipo di famiglia impostato su binomiale. Puoi vederli evidenziati nella dichiarazione sopra. Nel nostro caso, l'output atteso è binario ed è per questo che utilizziamo il tipo binomiale. Puoi esaminare gli altri parametri da solo; ad esempio, guarda alfa e lambda che avevamo specificato in precedenza. Fare riferimento alla documentazione del modello GLM per la spiegazione di tutti i parametri.

Ora, esegui questa dichiarazione. Al momento dell'esecuzione, verrà generato il seguente output:

Certamente, il tempo di esecuzione sarebbe diverso sulla tua macchina. Ora arriva la parte più interessante di questo codice di esempio.

Esame dell'output

Produciamo semplicemente il modello che abbiamo costruito usando la seguente dichiarazione:

getModel "glm_model"

Nota glm_model è l'ID del modello che abbiamo specificato come parametro model_id durante la creazione del modello nell'istruzione precedente. Questo ci dà un enorme output che dettaglia i risultati con diversi parametri variabili. Un output parziale del report è mostrato nello screenshot qui sotto:

Come puoi vedere nell'output, si dice che questo è il risultato dell'esecuzione dell'algoritmo di modellazione lineare generalizzata sul tuo set di dati.

Proprio sopra lo SCORING HISTORY, vedi il tag MODEL PARAMETERS, espandilo e vedrai l'elenco di tutti i parametri che vengono utilizzati durante la costruzione del modello. Questo è mostrato nello screenshot qui sotto.

Allo stesso modo, ogni tag fornisce un output dettagliato di un tipo specifico. Espandi tu stesso i vari tag per studiare gli output di diverso tipo.

Costruire un altro modello

Successivamente, costruiremo un modello di Deep Learning sul nostro dataframe. L'istruzione successiva nel codice di esempio è solo un commento di programma. La seguente dichiarazione è in realtà un comando di creazione del modello. È come mostrato qui -

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
}

Come puoi vedere nel codice sopra, specifichiamo deeplearning per la costruzione del modello con diversi parametri impostati sui valori appropriati come specificato nella documentazione del modello deeplearning. Quando si esegue questa istruzione, ci vorrà più tempo rispetto alla creazione del modello GLM. Verrà visualizzato il seguente output al termine della creazione del modello, sebbene con tempi diversi.

Esame dell'output del modello di deep learning

Questo genera il tipo di output, che può essere esaminato utilizzando la seguente istruzione come nel caso precedente.

getModel "deeplearning_model"

Considereremo l'output della curva ROC come mostrato di seguito per una rapida consultazione.

Come nel caso precedente, espandere le varie schede e studiare i diversi output.

Salvataggio del modello

Dopo aver studiato l'output di diversi modelli, decidi di utilizzarne uno nel tuo ambiente di produzione. H20 ti consente di salvare questo modello come POJO (Plain Old Java Object).

Espandi l'ultimo tag PREVIEW POJO nell'output e vedrai il codice Java per il tuo modello ottimizzato. Usalo nel tuo ambiente di produzione.

Successivamente, impareremo una caratteristica molto interessante di H2O. Impareremo come utilizzare AutoML per testare e classificare vari algoritmi in base alle loro prestazioni.

Per utilizzare AutoML, avvia un nuovo notebook Jupyter e segui i passaggi mostrati di seguito.

Importazione di AutoML

Per prima cosa importa il pacchetto H2O e AutoML nel progetto utilizzando le seguenti due istruzioni:

import h2o
from h2o.automl import H2OAutoML

Inizializza H2O

Inizializza h2o usando la seguente istruzione:

h2o.init()

Dovresti vedere le informazioni sul cluster sullo schermo come mostrato nello screenshot qui sotto -

Caricamento dati

Useremo lo stesso dataset iris.csv che hai usato in precedenza in questo tutorial. Carica i dati utilizzando la seguente istruzione:

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

Preparazione del set di dati

Dobbiamo decidere le caratteristiche e le colonne di previsione. Usiamo le stesse funzionalità e la colonna di previsione del nostro caso precedente. Impostare le caratteristiche e la colonna di output utilizzando le seguenti due istruzioni:

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

Dividi i dati in un rapporto 80:20 per addestramento e test -

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

Applicazione di AutoML

Ora siamo pronti per applicare AutoML al nostro set di dati. AutoML verrà eseguito per un periodo di tempo fisso da noi impostato e ci fornirà il modello ottimizzato. Abbiamo impostato l'AutoML utilizzando la seguente dichiarazione:

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

Il primo parametro specifica il numero di modelli che vogliamo valutare e confrontare.

Il secondo parametro specifica il tempo per il quale viene eseguito l'algoritmo.

Ora chiamiamo il metodo train sull'oggetto AutoML come mostrato qui -

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

Specifichiamo la x come matrice di caratteristiche che abbiamo creato in precedenza, la y come variabile di output per indicare il valore previsto e il dataframe come train set di dati.

Esegui il codice, dovrai aspettare 5 minuti (impostiamo max_runtime_secs a 300) fino a quando non ottieni il seguente output:

Stampa della classifica

Al termine dell'elaborazione AutoML, viene creata una classifica che classifica tutti i 30 algoritmi valutati. Per vedere i primi 10 record della classifica, utilizza il codice seguente:

lb = aml.leaderboard
lb.head()

Al momento dell'esecuzione, il codice precedente genererà il seguente output:

Chiaramente, l'algoritmo DeepLearning ha il punteggio massimo.

Previsione sui dati dei test

Ora che hai classificato i modelli, puoi vedere le prestazioni del modello più votato sui tuoi dati di test. A tale scopo, eseguire la seguente istruzione di codice:

preds = aml.predict(test)

L'elaborazione continua per un po 'e al termine verrà visualizzato il seguente output.

Risultato di stampa

Stampa il risultato previsto utilizzando la seguente dichiarazione:

print (preds)

Dopo l'esecuzione della dichiarazione di cui sopra, vedrai il seguente risultato:

Stampa della classifica per tutti

Se vuoi vedere i ranghi di tutti gli algoritmi testati, esegui la seguente dichiarazione di codice:

lb.head(rows = lb.nrows)

All'esecuzione dell'istruzione di cui sopra, verrà generato il seguente output (mostrato parzialmente):

Conclusione

H2O fornisce una piattaforma open source di facile utilizzo per applicare diversi algoritmi ML su un dato set di dati. Fornisce diversi algoritmi statistici e ML, incluso il deep learning. Durante il test, è possibile ottimizzare i parametri per questi algoritmi. Puoi farlo utilizzando la riga di comando o l'interfaccia basata sul web fornita chiamata Flow. H2O supporta anche AutoML che fornisce la classifica tra i diversi algoritmi in base alle loro prestazioni. H2O si comporta bene anche sui Big Data. Questo è sicuramente un vantaggio per Data Scientist applicare i diversi modelli di Machine Learning sul proprio set di dati e scegliere quello migliore per soddisfare le proprie esigenze.

↰ Previous page

H2O - Guida rapida

Installa in Python

Installazione delle dipendenze

Rimozione di versioni precedenti

Installazione della versione più recente

Verifica dell'installazione

Installa in R

Avvio di R Console

Rimozione di versioni precedenti

Download delle dipendenze

Installazione di H2O

Installa in R da CRAN

Installazione di prova

Installazione di Web GUI Flow

Installa su Hadoop / Anaconda Cloud

Sviluppo nel prompt dei comandi

In esecuzione in Jupyter

Applicazione di un algoritmo diverso

Avvio del flusso H2O

Cancellazione di tutte le uscite

Esecuzione della prima cella

Importazione di dati

Configurazione del parser dei dati

Analisi dei dati

Esame del dataframe

Costruire il modello

Esame dell'output

Costruire un altro modello

Esame dell'output del modello di deep learning

Salvataggio del modello

Importazione di AutoML

Inizializza H2O

Caricamento dati

Preparazione del set di dati

Applicazione di AutoML

Stampa della classifica

Previsione sui dati dei test

Risultato di stampa

Stampa della classifica per tutti

Conclusione

Tutorial H2O

Risorse utili H2O